Adding upstream version 7.0.6-dfsg.upstream/7.0.6-dfsgupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

41 files changed, 13786 insertions, 0 deletions

diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/ComponentName.c b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/ComponentName.c
new file mode 100644
index 00000000..aa470435
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/ComponentName.c
@@ -0,0 +1,343 @@
+/** @file
+
+Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved.<BR>
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+
+**/
+
+#include "Fat.h"
+
+//
+// EFI Component Name Functions
+//
+/**
+  Retrieves a Unicode string that is the user readable name of the driver.
+
+  This function retrieves the user readable name of a driver in the form of a
+  Unicode string. If the driver specified by This has a user readable name in
+  the language specified by Language, then a pointer to the driver name is
+  returned in DriverName, and EFI_SUCCESS is returned. If the driver specified
+  by This does not support the language specified by Language,
+  then EFI_UNSUPPORTED is returned.
+
+  @param  This[in]              A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
+                                EFI_COMPONENT_NAME_PROTOCOL instance.
+
+  @param  Language[in]          A pointer to a Null-terminated ASCII string
+                                array indicating the language. This is the
+                                language of the driver name that the caller is
+                                requesting, and it must match one of the
+                                languages specified in SupportedLanguages. The
+                                number of languages supported by a driver is up
+                                to the driver writer. Language is specified
+                                in RFC 4646 or ISO 639-2 language code format.
+
+  @param  DriverName[out]       A pointer to the Unicode string to return.
+                                This Unicode string is the name of the
+                                driver specified by This in the language
+                                specified by Language.
+
+  @retval EFI_SUCCESS           The Unicode string for the Driver specified by
+                                This and the language specified by Language was
+                                returned in DriverName.
+
+  @retval EFI_INVALID_PARAMETER Language is NULL.
+
+  @retval EFI_INVALID_PARAMETER DriverName is NULL.
+
+  @retval EFI_UNSUPPORTED       The driver specified by This does not support
+                                the language specified by Language.
+
+**/
+EFI_STATUS
+EFIAPI
+FatComponentNameGetDriverName (
+  IN  EFI_COMPONENT_NAME_PROTOCOL  *This,
+  IN  CHAR8                        *Language,
+  OUT CHAR16                       **DriverName
+  );
+
+
+/**
+  Retrieves a Unicode string that is the user readable name of the controller
+  that is being managed by a driver.
+
+  This function retrieves the user readable name of the controller specified by
+  ControllerHandle and ChildHandle in the form of a Unicode string. If the
+  driver specified by This has a user readable name in the language specified by
+  Language, then a pointer to the controller name is returned in ControllerName,
+  and EFI_SUCCESS is returned.  If the driver specified by This is not currently
+  managing the controller specified by ControllerHandle and ChildHandle,
+  then EFI_UNSUPPORTED is returned.  If the driver specified by This does not
+  support the language specified by Language, then EFI_UNSUPPORTED is returned.
+
+  @param  This[in]              A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
+                                EFI_COMPONENT_NAME_PROTOCOL instance.
+
+  @param  ControllerHandle[in]  The handle of a controller that the driver
+                                specified by This is managing.  This handle
+                                specifies the controller whose name is to be
+                                returned.
+
+  @param  ChildHandle[in]       The handle of the child controller to retrieve
+                                the name of.  This is an optional parameter that
+                                may be NULL.  It will be NULL for device
+                                drivers.  It will also be NULL for a bus drivers
+                                that wish to retrieve the name of the bus
+                                controller.  It will not be NULL for a bus
+                                driver that wishes to retrieve the name of a
+                                child controller.
+
+  @param  Language[in]          A pointer to a Null-terminated ASCII string
+                                array indicating the language.  This is the
+                                language of the driver name that the caller is
+                                requesting, and it must match one of the
+                                languages specified in SupportedLanguages. The
+                                number of languages supported by a driver is up
+                                to the driver writer. Language is specified in
+                                RFC 4646 or ISO 639-2 language code format.
+
+  @param  ControllerName[out]   A pointer to the Unicode string to return.
+                                This Unicode string is the name of the
+                                controller specified by ControllerHandle and
+                                ChildHandle in the language specified by
+                                Language from the point of view of the driver
+                                specified by This.
+
+  @retval EFI_SUCCESS           The Unicode string for the user readable name in
+                                the language specified by Language for the
+                                driver specified by This was returned in
+                                DriverName.
+
+  @retval EFI_INVALID_PARAMETER ControllerHandle is NULL.
+
+  @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid
+                                EFI_HANDLE.
+
+  @retval EFI_INVALID_PARAMETER Language is NULL.
+
+  @retval EFI_INVALID_PARAMETER ControllerName is NULL.
+
+  @retval EFI_UNSUPPORTED       The driver specified by This is not currently
+                                managing the controller specified by
+                                ControllerHandle and ChildHandle.
+
+  @retval EFI_UNSUPPORTED       The driver specified by This does not support
+                                the language specified by Language.
+
+**/
+EFI_STATUS
+EFIAPI
+FatComponentNameGetControllerName (
+  IN  EFI_COMPONENT_NAME_PROTOCOL                     *This,
+  IN  EFI_HANDLE                                      ControllerHandle,
+  IN  EFI_HANDLE                                      ChildHandle        OPTIONAL,
+  IN  CHAR8                                           *Language,
+  OUT CHAR16                                          **ControllerName
+  );
+
+//
+// EFI Component Name Protocol
+//
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME_PROTOCOL  gFatComponentName = {
+  FatComponentNameGetDriverName,
+  FatComponentNameGetControllerName,
+  "eng"
+};
+
+//
+// EFI Component Name 2 Protocol
+//
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME2_PROTOCOL gFatComponentName2 = {
+  (EFI_COMPONENT_NAME2_GET_DRIVER_NAME) FatComponentNameGetDriverName,
+  (EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME) FatComponentNameGetControllerName,
+  "en"
+};
+
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE mFatDriverNameTable[] = {
+  {
+    "eng;en",
+    L"FAT File System Driver"
+  },
+  {
+    NULL,
+    NULL
+  }
+};
+
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE mFatControllerNameTable[] = {
+  {
+    "eng;en",
+    L"FAT File System"
+  },
+  {
+    NULL,
+    NULL
+  }
+};
+
+
+/**
+  Retrieves a Unicode string that is the user readable name of the driver.
+
+  This function retrieves the user readable name of a driver in the form of a
+  Unicode string. If the driver specified by This has a user readable name in
+  the language specified by Language, then a pointer to the driver name is
+  returned in DriverName, and EFI_SUCCESS is returned. If the driver specified
+  by This does not support the language specified by Language,
+  then EFI_UNSUPPORTED is returned.
+
+  @param  This[in]              A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
+                                EFI_COMPONENT_NAME_PROTOCOL instance.
+
+  @param  Language[in]          A pointer to a Null-terminated ASCII string
+                                array indicating the language. This is the
+                                language of the driver name that the caller is
+                                requesting, and it must match one of the
+                                languages specified in SupportedLanguages. The
+                                number of languages supported by a driver is up
+                                to the driver writer. Language is specified
+                                in RFC 4646 or ISO 639-2 language code format.
+
+  @param  DriverName[out]       A pointer to the Unicode string to return.
+                                This Unicode string is the name of the
+                                driver specified by This in the language
+                                specified by Language.
+
+  @retval EFI_SUCCESS           The Unicode string for the Driver specified by
+                                This and the language specified by Language was
+                                returned in DriverName.
+
+  @retval EFI_INVALID_PARAMETER Language is NULL.
+
+  @retval EFI_INVALID_PARAMETER DriverName is NULL.
+
+  @retval EFI_UNSUPPORTED       The driver specified by This does not support
+                                the language specified by Language.
+
+**/
+EFI_STATUS
+EFIAPI
+FatComponentNameGetDriverName (
+  IN  EFI_COMPONENT_NAME_PROTOCOL  *This,
+  IN  CHAR8                        *Language,
+  OUT CHAR16                       **DriverName
+  )
+{
+  return LookupUnicodeString2 (
+           Language,
+           This->SupportedLanguages,
+           mFatDriverNameTable,
+           DriverName,
+           (BOOLEAN)(This == &gFatComponentName)
+           );
+}
+
+/**
+  Retrieves a Unicode string that is the user readable name of the controller
+  that is being managed by a driver.
+
+  This function retrieves the user readable name of the controller specified by
+  ControllerHandle and ChildHandle in the form of a Unicode string. If the
+  driver specified by This has a user readable name in the language specified by
+  Language, then a pointer to the controller name is returned in ControllerName,
+  and EFI_SUCCESS is returned.  If the driver specified by This is not currently
+  managing the controller specified by ControllerHandle and ChildHandle,
+  then EFI_UNSUPPORTED is returned.  If the driver specified by This does not
+  support the language specified by Language, then EFI_UNSUPPORTED is returned.
+
+  @param  This[in]              A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
+                                EFI_COMPONENT_NAME_PROTOCOL instance.
+
+  @param  ControllerHandle[in]  The handle of a controller that the driver
+                                specified by This is managing.  This handle
+                                specifies the controller whose name is to be
+                                returned.
+
+  @param  ChildHandle[in]       The handle of the child controller to retrieve
+                                the name of.  This is an optional parameter that
+                                may be NULL.  It will be NULL for device
+                                drivers.  It will also be NULL for a bus drivers
+                                that wish to retrieve the name of the bus
+                                controller.  It will not be NULL for a bus
+                                driver that wishes to retrieve the name of a
+                                child controller.
+
+  @param  Language[in]          A pointer to a Null-terminated ASCII string
+                                array indicating the language.  This is the
+                                language of the driver name that the caller is
+                                requesting, and it must match one of the
+                                languages specified in SupportedLanguages. The
+                                number of languages supported by a driver is up
+                                to the driver writer. Language is specified in
+                                RFC 4646 or ISO 639-2 language code format.
+
+  @param  ControllerName[out]   A pointer to the Unicode string to return.
+                                This Unicode string is the name of the
+                                controller specified by ControllerHandle and
+                                ChildHandle in the language specified by
+                                Language from the point of view of the driver
+                                specified by This.
+
+  @retval EFI_SUCCESS           The Unicode string for the user readable name in
+                                the language specified by Language for the
+                                driver specified by This was returned in
+                                DriverName.
+
+  @retval EFI_INVALID_PARAMETER ControllerHandle is NULL.
+
+  @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid
+                                EFI_HANDLE.
+
+  @retval EFI_INVALID_PARAMETER Language is NULL.
+
+  @retval EFI_INVALID_PARAMETER ControllerName is NULL.
+
+  @retval EFI_UNSUPPORTED       The driver specified by This is not currently
+                                managing the controller specified by
+                                ControllerHandle and ChildHandle.
+
+  @retval EFI_UNSUPPORTED       The driver specified by This does not support
+                                the language specified by Language.
+
+**/
+EFI_STATUS
+EFIAPI
+FatComponentNameGetControllerName (
+  IN  EFI_COMPONENT_NAME_PROTOCOL                     *This,
+  IN  EFI_HANDLE                                      ControllerHandle,
+  IN  EFI_HANDLE                                      ChildHandle        OPTIONAL,
+  IN  CHAR8                                           *Language,
+  OUT CHAR16                                          **ControllerName
+  )
+{
+  EFI_STATUS  Status;
+
+  //
+  // This is a device driver, so ChildHandle must be NULL.
+  //
+  if (ChildHandle != NULL) {
+    return EFI_UNSUPPORTED;
+  }
+
+  //
+  // Make sure this driver is currently managing ControllHandle
+  //
+  Status = EfiTestManagedDevice (
+             ControllerHandle,
+             gFatDriverBinding.DriverBindingHandle,
+             &gEfiDiskIoProtocolGuid
+             );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  return LookupUnicodeString2 (
+           Language,
+           This->SupportedLanguages,
+           mFatControllerNameTable,
+           ControllerName,
+           (BOOLEAN)(This == &gFatComponentName)
+           );
+}
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Data.c b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Data.c
new file mode 100644
index 00000000..95898bbc
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Data.c
@@ -0,0 +1,40 @@
+/** @file
+  Global data in the FAT Filesystem driver.
+
+Copyright (c) 2005 - 2013, Intel Corporation. All rights reserved.<BR>
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "Fat.h"
+
+//
+// Globals
+//
+//
+// FatFsLock - Global lock for synchronizing all requests.
+//
+EFI_LOCK FatFsLock   = EFI_INITIALIZE_LOCK_VARIABLE (TPL_CALLBACK);
+
+EFI_LOCK FatTaskLock = EFI_INITIALIZE_LOCK_VARIABLE (TPL_NOTIFY);
+
+//
+// Filesystem interface functions
+//
+EFI_FILE_PROTOCOL               FatFileInterface = {
+  EFI_FILE_PROTOCOL_REVISION,
+  FatOpen,
+  FatClose,
+  FatDelete,
+  FatRead,
+  FatWrite,
+  FatGetPosition,
+  FatSetPosition,
+  FatGetInfo,
+  FatSetInfo,
+  FatFlush,
+  FatOpenEx,
+  FatReadEx,
+  FatWriteEx,
+  FatFlushEx
+};
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Delete.c b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Delete.c
new file mode 100644
index 00000000..2215bb6d
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Delete.c
@@ -0,0 +1,119 @@
+/** @file
+  Function that deletes a file.
+
+Copyright (c) 2005 - 2013, Intel Corporation. All rights reserved.<BR>
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+
+**/
+
+#include "Fat.h"
+
+/**
+
+  Deletes the file & Closes the file handle.
+
+  @param  FHand                    - Handle to the file to delete.
+
+  @retval EFI_SUCCESS              - Delete the file successfully.
+  @retval EFI_WARN_DELETE_FAILURE  - Fail to delete the file.
+
+**/
+EFI_STATUS
+EFIAPI
+FatDelete (
+  IN EFI_FILE_PROTOCOL  *FHand
+  )
+{
+  FAT_IFILE   *IFile;
+  FAT_OFILE   *OFile;
+  FAT_DIRENT  *DirEnt;
+  EFI_STATUS  Status;
+  UINTN       Round;
+
+  IFile = IFILE_FROM_FHAND (FHand);
+  OFile = IFile->OFile;
+
+  FatWaitNonblockingTask (IFile);
+
+  //
+  // Lock the volume
+  //
+  FatAcquireLock ();
+
+  //
+  // If the file is read-only, then don't delete it
+  //
+  if (IFile->ReadOnly) {
+    Status = EFI_WRITE_PROTECTED;
+    goto Done;
+  }
+  //
+  // If the file is the root dir, then don't delete it
+  //
+  if (OFile->Parent == NULL) {
+    Status = EFI_ACCESS_DENIED;
+    goto Done;
+  }
+  //
+  // If the file has a permanent error, skip the delete
+  //
+  Status = OFile->Error;
+  if (!EFI_ERROR (Status)) {
+    //
+    // If this is a directory, make sure it's empty before
+    // allowing it to be deleted
+    //
+    if (OFile->ODir != NULL) {
+      //
+      // We do not allow to delete nonempty directory
+      //
+      FatResetODirCursor (OFile);
+      for (Round = 0; Round < 3; Round++) {
+        Status = FatGetNextDirEnt (OFile, &DirEnt);
+        if ((EFI_ERROR (Status)) ||
+            ((Round < 2) && (DirEnt == NULL || !FatIsDotDirEnt (DirEnt))) ||
+            ((Round == 2) && (DirEnt != NULL))
+            ) {
+          Status = EFI_ACCESS_DENIED;
+          goto Done;
+        }
+      }
+    }
+    //
+    // Return the file's space by setting its size to 0
+    //
+    FatTruncateOFile (OFile, 0);
+    //
+    // Free the directory entry for this file
+    //
+    Status = FatRemoveDirEnt (OFile->Parent, OFile->DirEnt);
+    if (EFI_ERROR (Status)) {
+      goto Done;
+    }
+    //
+    // Set a permanent error for this OFile in case there
+    // are still opened IFiles attached
+    //
+    OFile->Error = EFI_NOT_FOUND;
+  } else if (OFile->Error == EFI_NOT_FOUND) {
+    Status = EFI_SUCCESS;
+  }
+
+Done:
+  //
+  // Always close the handle
+  //
+  FatIFileClose (IFile);
+  //
+  // Done
+  //
+  Status = FatCleanupVolume (OFile->Volume, NULL, Status, NULL);
+  FatReleaseLock ();
+
+  if (EFI_ERROR (Status)) {
+    Status = EFI_WARN_DELETE_FAILURE;
+  }
+
+  return Status;
+}
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/DirectoryCache.c b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/DirectoryCache.c
new file mode 100644
index 00000000..318e78f6
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/DirectoryCache.c
@@ -0,0 +1,184 @@
+/** @file
+  Functions for directory cache operation.
+
+Copyright (c) 2005, Intel Corporation. All rights reserved.<BR>
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+
+**/
+
+#include "Fat.h"
+
+/**
+
+  Free the directory structure and release the memory.
+
+  @param  ODir                  - The directory to be freed.
+
+**/
+STATIC
+VOID
+FatFreeODir (
+  IN FAT_ODIR    *ODir
+  )
+{
+  FAT_DIRENT  *DirEnt;
+
+  //
+  // Release Directory Entry Nodes
+  //
+  while (!IsListEmpty (&ODir->ChildList)) {
+    DirEnt = DIRENT_FROM_LINK (ODir->ChildList.ForwardLink);
+    RemoveEntryList (&DirEnt->Link);
+    //
+    // Make sure the OFile has been closed
+    //
+    ASSERT (DirEnt->OFile == NULL);
+    FatFreeDirEnt (DirEnt);
+  }
+
+  FreePool (ODir);
+}
+
+/**
+
+  Allocate the directory structure.
+
+  @param  OFile                   - The corresponding OFile.
+
+**/
+STATIC
+FAT_ODIR *
+FatAllocateODir (
+  IN FAT_OFILE   *OFile
+  )
+{
+  FAT_ODIR  *ODir;
+
+  ODir = AllocateZeroPool (sizeof (FAT_ODIR));
+  if (ODir != NULL) {
+    //
+    // Initialize the directory entry list
+    //
+    ODir->Signature = FAT_ODIR_SIGNATURE;
+    InitializeListHead (&ODir->ChildList);
+    ODir->CurrentCursor = &ODir->ChildList;
+  }
+
+  return ODir;
+}
+
+/**
+
+  Discard the directory structure when an OFile will be freed.
+  Volume will cache this directory if the OFile does not represent a deleted file.
+
+  @param  OFile                 - The OFile whose directory structure is to be discarded.
+
+**/
+VOID
+FatDiscardODir (
+  IN FAT_OFILE    *OFile
+  )
+{
+  FAT_ODIR    *ODir;
+  FAT_VOLUME  *Volume;
+
+  Volume  = OFile->Volume;
+  ODir    = OFile->ODir;
+  if (!OFile->DirEnt->Invalid) {
+    //
+    // If OFile does not represent a deleted file, then we will cache the directory
+    // We use OFile's first cluster as the directory's tag
+    //
+    ODir->DirCacheTag = OFile->FileCluster;
+    InsertHeadList (&Volume->DirCacheList, &ODir->DirCacheLink);
+    if (Volume->DirCacheCount == FAT_MAX_DIR_CACHE_COUNT) {
+      //
+      // Replace the least recent used directory
+      //
+      ODir = ODIR_FROM_DIRCACHELINK (Volume->DirCacheList.BackLink);
+      RemoveEntryList (&ODir->DirCacheLink);
+    } else {
+      //
+      // No need to find a replace
+      //
+      Volume->DirCacheCount++;
+      ODir = NULL;
+    }
+  }
+  //
+  // Release ODir Structure
+  //
+  if (ODir != NULL) {
+    FatFreeODir (ODir);
+  }
+}
+
+/**
+
+
+  Request the directory structure when an OFile is newly generated.
+  If the directory structure is cached by volume, then just return this directory;
+  Otherwise, allocate a new one for OFile.
+
+  @param  OFile                 - The OFile which requests directory structure.
+
+**/
+VOID
+FatRequestODir (
+  IN FAT_OFILE    *OFile
+  )
+{
+  UINTN           DirCacheTag;
+  FAT_VOLUME      *Volume;
+  FAT_ODIR        *ODir;
+  FAT_ODIR        *CurrentODir;
+  LIST_ENTRY      *CurrentODirLink;
+
+  Volume      = OFile->Volume;
+  ODir        = NULL;
+  DirCacheTag = OFile->FileCluster;
+  for (CurrentODirLink  = Volume->DirCacheList.ForwardLink;
+       CurrentODirLink != &Volume->DirCacheList;
+       CurrentODirLink  = CurrentODirLink->ForwardLink
+      ) {
+    CurrentODir = ODIR_FROM_DIRCACHELINK (CurrentODirLink);
+    if (CurrentODir->DirCacheTag == DirCacheTag) {
+      RemoveEntryList (&CurrentODir->DirCacheLink);
+      Volume->DirCacheCount--;
+      ODir = CurrentODir;
+      break;
+    }
+  }
+
+  if (ODir == NULL) {
+    //
+    // This directory is not cached, then allocate a new one
+    //
+    ODir = FatAllocateODir (OFile);
+  }
+
+  OFile->ODir = ODir;
+}
+
+/**
+
+  Clean up all the cached directory structures when the volume is going to be abandoned.
+
+  @param  Volume                - FAT file system volume.
+
+**/
+VOID
+FatCleanupODirCache (
+  IN FAT_VOLUME         *Volume
+  )
+{
+  FAT_ODIR  *ODir;
+  while (Volume->DirCacheCount > 0) {
+    ODir = ODIR_FROM_DIRCACHELINK (Volume->DirCacheList.BackLink);
+    RemoveEntryList (&ODir->DirCacheLink);
+    FatFreeODir (ODir);
+    Volume->DirCacheCount--;
+  }
+}
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/DirectoryManage.c b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/DirectoryManage.c
new file mode 100644
index 00000000..7d9abbc5
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/DirectoryManage.c
@@ -0,0 +1,1391 @@
+/** @file
+  Functions for performing directory entry io.
+
+Copyright (c) 2005 - 2015, Intel Corporation. All rights reserved.<BR>
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "Fat.h"
+
+/**
+
+  Get a directory entry from disk for the Ofile.
+
+  @param  Parent                - The parent of the OFile which need to update.
+  @param  IoMode                - Indicate whether to read directory entry or write directory entry.
+  @param  EntryPos              - The position of the directory entry to be accessed.
+  @param  Entry                 - The directory entry read or written.
+
+  @retval EFI_SUCCESS           - Access the directory entry successfully.
+  @return other                 - An error occurred when reading the directory entry.
+
+**/
+STATIC
+EFI_STATUS
+FatAccessEntry (
+  IN     FAT_OFILE            *Parent,
+  IN     IO_MODE              IoMode,
+  IN     UINTN                EntryPos,
+  IN OUT VOID                 *Entry
+  )
+{
+  UINTN Position;
+  UINTN BufferSize;
+
+  Position = EntryPos * sizeof (FAT_DIRECTORY_ENTRY);
+  if (Position >= Parent->FileSize) {
+    //
+    // End of directory
+    //
+    ASSERT (IoMode == ReadData);
+    ((FAT_DIRECTORY_ENTRY *) Entry)->FileName[0] = EMPTY_ENTRY_MARK;
+    ((FAT_DIRECTORY_ENTRY *) Entry)->Attributes  = 0;
+    return EFI_SUCCESS;
+  }
+
+  BufferSize = sizeof (FAT_DIRECTORY_ENTRY);
+  return FatAccessOFile (Parent, IoMode, Position, &BufferSize, Entry, NULL);
+}
+
+/**
+
+  Save the directory entry to disk.
+
+  @param  OFile                 - The parent OFile which needs to update.
+  @param  DirEnt                - The directory entry to be saved.
+
+  @retval EFI_SUCCESS           - Store the directory entry successfully.
+  @return other                 - An error occurred when writing the directory entry.
+
+**/
+EFI_STATUS
+FatStoreDirEnt (
+  IN FAT_OFILE            *OFile,
+  IN FAT_DIRENT           *DirEnt
+  )
+{
+  EFI_STATUS        Status;
+  FAT_DIRECTORY_LFN LfnEntry;
+  UINTN             EntryPos;
+  CHAR16            *LfnBufferPointer;
+  CHAR16            LfnBuffer[MAX_LFN_ENTRIES * LFN_CHAR_TOTAL + 1];
+  UINT8             EntryCount;
+  UINT8             LfnOrdinal;
+
+  EntryPos   = DirEnt->EntryPos;
+  EntryCount = DirEnt->EntryCount;
+  //
+  // Write directory entry
+  //
+  Status = FatAccessEntry (OFile, WriteData, EntryPos, &DirEnt->Entry);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  if (--EntryCount > 0) {
+    //
+    // Write LFN directory entry
+    //
+    SetMem (LfnBuffer, sizeof (CHAR16) * LFN_CHAR_TOTAL * EntryCount, 0xff);
+    Status = StrCpyS (
+               LfnBuffer,
+               ARRAY_SIZE (LfnBuffer),
+               DirEnt->FileString
+               );
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+
+    LfnBufferPointer    = LfnBuffer;
+    LfnEntry.Attributes = FAT_ATTRIBUTE_LFN;
+    LfnEntry.Type       = 0;
+    LfnEntry.MustBeZero = 0;
+    LfnEntry.Checksum   = FatCheckSum (DirEnt->Entry.FileName);
+    for (LfnOrdinal = 1; LfnOrdinal <= EntryCount; LfnOrdinal++) {
+      LfnEntry.Ordinal = LfnOrdinal;
+      if (LfnOrdinal == EntryCount) {
+        LfnEntry.Ordinal |= FAT_LFN_LAST;
+      }
+
+      CopyMem (LfnEntry.Name1, LfnBufferPointer, sizeof (CHAR16) * LFN_CHAR1_LEN);
+      LfnBufferPointer += LFN_CHAR1_LEN;
+      CopyMem (LfnEntry.Name2, LfnBufferPointer, sizeof (CHAR16) * LFN_CHAR2_LEN);
+      LfnBufferPointer += LFN_CHAR2_LEN;
+      CopyMem (LfnEntry.Name3, LfnBufferPointer, sizeof (CHAR16) * LFN_CHAR3_LEN);
+      LfnBufferPointer += LFN_CHAR3_LEN;
+      EntryPos--;
+      if (DirEnt->Invalid) {
+        LfnEntry.Ordinal = DELETE_ENTRY_MARK;
+      }
+
+      Status = FatAccessEntry (OFile, WriteData, EntryPos, &LfnEntry);
+      if (EFI_ERROR (Status)) {
+        return Status;
+      }
+    }
+  }
+
+  return EFI_SUCCESS;
+}
+
+/**
+
+  Determine whether the directory entry is "." or ".." entry.
+
+  @param  DirEnt               - The corresponding directory entry.
+
+  @retval TRUE                 - The directory entry is "." or ".." directory entry
+  @retval FALSE                - The directory entry is not "." or ".." directory entry
+
+**/
+BOOLEAN
+FatIsDotDirEnt (
+  IN FAT_DIRENT  *DirEnt
+  )
+{
+  CHAR16  *FileString;
+  FileString = DirEnt->FileString;
+  if (StrCmp (FileString, L".") == 0 || StrCmp (FileString, L"..") == 0) {
+    return TRUE;
+  }
+
+  return FALSE;
+}
+
+/**
+
+  Set the OFile's cluster info in its directory entry.
+
+  @param  OFile                 - The corresponding OFile.
+
+**/
+STATIC
+VOID
+FatSetDirEntCluster (
+  IN FAT_OFILE    *OFile
+  )
+{
+  UINTN       Cluster;
+  FAT_DIRENT  *DirEnt;
+
+  DirEnt                        = OFile->DirEnt;
+  Cluster                       = OFile->FileCluster;
+  DirEnt->Entry.FileClusterHigh = (UINT16) (Cluster >> 16);
+  DirEnt->Entry.FileCluster     = (UINT16) Cluster;
+}
+
+/**
+
+  Set the OFile's cluster and size info in its directory entry.
+
+  @param  OFile                 - The corresponding OFile.
+
+**/
+VOID
+FatUpdateDirEntClusterSizeInfo (
+  IN FAT_OFILE    *OFile
+  )
+{
+  ASSERT (OFile->ODir == NULL);
+  OFile->DirEnt->Entry.FileSize = (UINT32) OFile->FileSize;
+  FatSetDirEntCluster (OFile);
+}
+
+/**
+
+  Copy all the information of DirEnt2 to DirEnt1 except for 8.3 name.
+
+  @param  DirEnt1               - The destination directory entry.
+  @param  DirEnt2               - The source directory entry.
+
+**/
+VOID
+FatCloneDirEnt (
+  IN  FAT_DIRENT          *DirEnt1,
+  IN  FAT_DIRENT          *DirEnt2
+  )
+{
+  UINT8 *Entry1;
+  UINT8 *Entry2;
+  Entry1  = (UINT8 *) &DirEnt1->Entry;
+  Entry2  = (UINT8 *) &DirEnt2->Entry;
+  CopyMem (
+    Entry1 + FAT_ENTRY_INFO_OFFSET,
+    Entry2 + FAT_ENTRY_INFO_OFFSET,
+    sizeof (FAT_DIRECTORY_ENTRY) - FAT_ENTRY_INFO_OFFSET
+    );
+}
+
+/**
+
+  Get the LFN for the directory entry.
+
+  @param  Parent                - The parent directory.
+  @param  DirEnt                - The directory entry to get LFN.
+
+**/
+STATIC
+VOID
+FatLoadLongNameEntry (
+  IN FAT_OFILE           *Parent,
+  IN FAT_DIRENT          *DirEnt
+  )
+{
+  CHAR16            LfnBuffer[MAX_LFN_ENTRIES * LFN_CHAR_TOTAL + 1];
+  CHAR16            *LfnBufferPointer;
+  CHAR8             *File8Dot3Name;
+  UINTN             EntryPos;
+  UINT8             LfnOrdinal;
+  UINT8             LfnChecksum;
+  FAT_DIRECTORY_LFN LfnEntry;
+  EFI_STATUS        Status;
+
+  EntryPos          = DirEnt->EntryPos;
+  File8Dot3Name     = DirEnt->Entry.FileName;
+  LfnBufferPointer  = LfnBuffer;
+  //
+  // Computes checksum for LFN
+  //
+  LfnChecksum = FatCheckSum (File8Dot3Name);
+  LfnOrdinal  = 1;
+  do {
+    if (EntryPos == 0) {
+      LfnBufferPointer = LfnBuffer;
+      break;
+    }
+
+    EntryPos--;
+    Status = FatAccessEntry (Parent, ReadData, EntryPos, &LfnEntry);
+    if (EFI_ERROR (Status) ||
+        LfnEntry.Attributes != FAT_ATTRIBUTE_LFN ||
+        LfnEntry.MustBeZero != 0 ||
+        LfnEntry.Checksum != LfnChecksum ||
+        (LfnEntry.Ordinal & (~FAT_LFN_LAST)) != LfnOrdinal ||
+        LfnOrdinal > MAX_LFN_ENTRIES
+        ) {
+      //
+      // The directory entry does not have a long file name or
+      // some error occurs when loading long file name for a directory entry,
+      // and then we load the long name from short name
+      //
+      LfnBufferPointer = LfnBuffer;
+      break;
+    }
+
+    CopyMem (LfnBufferPointer, LfnEntry.Name1, sizeof (CHAR16) * LFN_CHAR1_LEN);
+    LfnBufferPointer += LFN_CHAR1_LEN;
+    CopyMem (LfnBufferPointer, LfnEntry.Name2, sizeof (CHAR16) * LFN_CHAR2_LEN);
+    LfnBufferPointer += LFN_CHAR2_LEN;
+    CopyMem (LfnBufferPointer, LfnEntry.Name3, sizeof (CHAR16) * LFN_CHAR3_LEN);
+    LfnBufferPointer += LFN_CHAR3_LEN;
+    LfnOrdinal++;
+  } while ((LfnEntry.Ordinal & FAT_LFN_LAST) == 0);
+  DirEnt->EntryCount = LfnOrdinal;
+  //
+  // Terminate current Lfnbuffer
+  //
+  *LfnBufferPointer = 0;
+  if (LfnBufferPointer == LfnBuffer) {
+    //
+    // Fail to get the long file name from long file name entry,
+    // get the file name from short name
+    //
+    FatGetFileNameViaCaseFlag (
+      DirEnt,
+      LfnBuffer,
+      ARRAY_SIZE (LfnBuffer)
+      );
+  }
+
+  DirEnt->FileString = AllocateCopyPool (StrSize (LfnBuffer), LfnBuffer);
+}
+
+/**
+
+  Add this directory entry node to the list of directory entries and hash table.
+
+  @param  ODir                  - The parent OFile which needs to be updated.
+  @param  DirEnt                - The directory entry to be added.
+
+**/
+STATIC
+VOID
+FatAddDirEnt (
+  IN FAT_ODIR             *ODir,
+  IN FAT_DIRENT           *DirEnt
+  )
+{
+  if (DirEnt->Link.BackLink == NULL) {
+    DirEnt->Link.BackLink = &ODir->ChildList;
+  }
+  InsertTailList (DirEnt->Link.BackLink, &DirEnt->Link);
+  FatInsertToHashTable (ODir, DirEnt);
+}
+
+/**
+
+  Load from disk the next directory entry at current end of directory position.
+
+  @param  OFile                 - The parent OFile.
+  @param  PtrDirEnt             - The directory entry that is loaded.
+
+  @retval EFI_SUCCESS           - Load the directory entry successfully.
+  @retval EFI_OUT_OF_RESOURCES  - Out of resource.
+  @return other                 - An error occurred when reading the directory entries.
+
+**/
+STATIC
+EFI_STATUS
+FatLoadNextDirEnt (
+  IN  FAT_OFILE           *OFile,
+  OUT FAT_DIRENT          **PtrDirEnt
+  )
+{
+  EFI_STATUS          Status;
+  FAT_DIRENT          *DirEnt;
+  FAT_ODIR            *ODir;
+  FAT_DIRECTORY_ENTRY Entry;
+
+  ODir = OFile->ODir;
+  //
+  // Make sure the parent's directory has been opened
+  //
+  ASSERT (ODir != NULL);
+  //
+  // Assert we have not reached the end of directory
+  //
+  ASSERT (!ODir->EndOfDir);
+  DirEnt = NULL;
+
+  for (;;) {
+    //
+    // Read the next directory entry until we find a valid directory entry (excluding lfn entry)
+    //
+    Status = FatAccessEntry (OFile, ReadData, ODir->CurrentEndPos, &Entry);
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+
+    if (((UINT8) Entry.FileName[0] != DELETE_ENTRY_MARK) && (Entry.Attributes & FAT_ATTRIBUTE_VOLUME_ID) == 0) {
+      //
+      // We get a valid directory entry, then handle it
+      //
+      break;
+    }
+
+    ODir->CurrentEndPos++;
+  }
+
+  if (Entry.FileName[0] != EMPTY_ENTRY_MARK) {
+    //
+    // Although FAT spec states this field is always 0 for FAT12 & FAT16, some applications
+    // might use it for some special usage, it is safer to zero it in memory for FAT12 & FAT16.
+    //
+    if (OFile->Volume->FatType != Fat32) {
+      Entry.FileClusterHigh = 0;
+    }
+
+    //
+    // This is a valid directory entry
+    //
+    DirEnt = AllocateZeroPool (sizeof (FAT_DIRENT));
+    if (DirEnt == NULL) {
+      return EFI_OUT_OF_RESOURCES;
+    }
+
+    DirEnt->Signature = FAT_DIRENT_SIGNATURE;
+    //
+    // Remember the directory's entry position on disk
+    //
+    DirEnt->EntryPos = (UINT16) ODir->CurrentEndPos;
+    CopyMem (&DirEnt->Entry, &Entry, sizeof (FAT_DIRECTORY_ENTRY));
+    FatLoadLongNameEntry (OFile, DirEnt);
+    if (DirEnt->FileString == NULL) {
+      Status = EFI_OUT_OF_RESOURCES;
+      goto Done;
+    }
+    //
+    // Add this directory entry to directory
+    //
+    FatAddDirEnt (ODir, DirEnt);
+    //
+    // Point to next directory entry
+    //
+    ODir->CurrentEndPos++;
+  } else {
+    ODir->EndOfDir = TRUE;
+  }
+
+  *PtrDirEnt = DirEnt;
+  return EFI_SUCCESS;
+
+Done:
+  FatFreeDirEnt (DirEnt);
+  return Status;
+}
+
+/**
+
+  Get the directory entry's info into Buffer.
+
+  @param  Volume                - FAT file system volume.
+  @param  DirEnt                - The corresponding directory entry.
+  @param  BufferSize            - Size of Buffer.
+  @param  Buffer                - Buffer containing file info.
+
+  @retval EFI_SUCCESS           - Get the file info successfully.
+  @retval EFI_BUFFER_TOO_SMALL  - The buffer is too small.
+
+**/
+EFI_STATUS
+FatGetDirEntInfo (
+  IN     FAT_VOLUME         *Volume,
+  IN     FAT_DIRENT         *DirEnt,
+  IN OUT UINTN              *BufferSize,
+     OUT VOID               *Buffer
+  )
+{
+  UINTN               Size;
+  UINTN               NameSize;
+  UINTN               ResultSize;
+  UINTN               Cluster;
+  EFI_STATUS          Status;
+  EFI_FILE_INFO       *Info;
+  FAT_DIRECTORY_ENTRY *Entry;
+  FAT_DATE_TIME       FatLastAccess;
+
+  ASSERT_VOLUME_LOCKED (Volume);
+
+  Size        = SIZE_OF_EFI_FILE_INFO;
+  NameSize    = StrSize (DirEnt->FileString);
+  ResultSize  = Size + NameSize;
+
+  Status      = EFI_BUFFER_TOO_SMALL;
+  if (*BufferSize >= ResultSize) {
+    Status      = EFI_SUCCESS;
+    Entry       = &DirEnt->Entry;
+    Info        = Buffer;
+    Info->Size  = ResultSize;
+    if ((Entry->Attributes & FAT_ATTRIBUTE_DIRECTORY) != 0) {
+      Cluster             = (Entry->FileClusterHigh << 16) | Entry->FileCluster;
+      Info->PhysicalSize  = FatPhysicalDirSize (Volume, Cluster);
+      Info->FileSize      = Info->PhysicalSize;
+    } else {
+      Info->FileSize      = Entry->FileSize;
+      Info->PhysicalSize  = FatPhysicalFileSize (Volume, Entry->FileSize);
+    }
+
+    ZeroMem (&FatLastAccess.Time, sizeof (FatLastAccess.Time));
+    CopyMem (&FatLastAccess.Date, &Entry->FileLastAccess, sizeof (FatLastAccess.Date));
+    FatFatTimeToEfiTime (&FatLastAccess, &Info->LastAccessTime);
+    FatFatTimeToEfiTime (&Entry->FileCreateTime, &Info->CreateTime);
+    FatFatTimeToEfiTime (&Entry->FileModificationTime, &Info->ModificationTime);
+    Info->Attribute = Entry->Attributes & EFI_FILE_VALID_ATTR;
+    CopyMem ((CHAR8 *) Buffer + Size, DirEnt->FileString, NameSize);
+  }
+
+  *BufferSize = ResultSize;
+  return Status;
+}
+
+/**
+
+  Search the directory for the directory entry whose filename is FileNameString.
+
+  @param  OFile                 - The parent OFile whose directory is to be searched.
+  @param  FileNameString        - The filename to be searched.
+  @param  PtrDirEnt             - pointer to the directory entry if found.
+
+  @retval EFI_SUCCESS           - Find the directory entry or not found.
+  @return other                 - An error occurred when reading the directory entries.
+
+**/
+STATIC
+EFI_STATUS
+FatSearchODir (
+  IN  FAT_OFILE      *OFile,
+  IN  CHAR16         *FileNameString,
+  OUT FAT_DIRENT     **PtrDirEnt
+  )
+{
+  BOOLEAN     PossibleShortName;
+  CHAR8       File8Dot3Name[FAT_NAME_LEN];
+  FAT_ODIR    *ODir;
+  FAT_DIRENT  *DirEnt;
+  EFI_STATUS  Status;
+
+  ODir = OFile->ODir;
+  ASSERT (ODir != NULL);
+  //
+  // Check if the file name is a valid short name
+  //
+  PossibleShortName = FatCheckIs8Dot3Name (FileNameString, File8Dot3Name);
+  //
+  // Search the hash table first
+  //
+  DirEnt = *FatLongNameHashSearch (ODir, FileNameString);
+  if (DirEnt == NULL && PossibleShortName) {
+      DirEnt = *FatShortNameHashSearch (ODir, File8Dot3Name);
+  }
+  if (DirEnt == NULL) {
+    //
+    // We fail to get the directory entry from hash table; we then
+    // search the rest directory
+    //
+    while (!ODir->EndOfDir) {
+      Status = FatLoadNextDirEnt (OFile, &DirEnt);
+      if (EFI_ERROR (Status)) {
+        return Status;
+      }
+
+      if (DirEnt != NULL) {
+        if (FatStriCmp (FileNameString, DirEnt->FileString) == 0) {
+          break;
+        }
+
+        if (PossibleShortName && CompareMem (File8Dot3Name, DirEnt->Entry.FileName, FAT_NAME_LEN) == 0) {
+          break;
+        }
+      }
+    }
+  }
+
+  *PtrDirEnt = DirEnt;
+  return EFI_SUCCESS;
+}
+
+/**
+
+  Set the OFile's current directory cursor to the list head.
+
+  @param OFile                 - The directory OFile whose directory cursor is reset.
+
+**/
+VOID
+FatResetODirCursor (
+  IN FAT_OFILE    *OFile
+  )
+{
+  FAT_ODIR  *ODir;
+
+  ODir = OFile->ODir;
+  ASSERT (ODir != NULL);
+  ODir->CurrentCursor = &(ODir->ChildList);
+  ODir->CurrentPos    = 0;
+}
+
+/**
+
+  Set the directory's cursor to the next and get the next directory entry.
+
+  @param  OFile                 - The parent OFile.
+  @param PtrDirEnt             - The next directory entry.
+
+  @retval EFI_SUCCESS           - We get the next directory entry successfully.
+  @return other                 - An error occurred when get next directory entry.
+
+**/
+EFI_STATUS
+FatGetNextDirEnt (
+  IN  FAT_OFILE     *OFile,
+  OUT FAT_DIRENT    **PtrDirEnt
+  )
+{
+  EFI_STATUS  Status;
+  FAT_DIRENT  *DirEnt;
+  FAT_ODIR    *ODir;
+
+  ODir = OFile->ODir;
+  ASSERT (ODir != NULL);
+  if (ODir->CurrentCursor->ForwardLink == &ODir->ChildList) {
+    //
+    // End of directory, we will try one more time
+    //
+    if (!ODir->EndOfDir) {
+      //
+      // Read directory from disk
+      //
+      Status = FatLoadNextDirEnt (OFile, &DirEnt);
+      if (EFI_ERROR (Status)) {
+        return Status;
+      }
+    }
+  }
+
+  if (ODir->CurrentCursor->ForwardLink == &ODir->ChildList) {
+    //
+    // End of directory, return NULL
+    //
+    DirEnt              = NULL;
+    ODir->CurrentPos    = ODir->CurrentEndPos;
+  } else {
+    ODir->CurrentCursor = ODir->CurrentCursor->ForwardLink;
+    DirEnt              = DIRENT_FROM_LINK (ODir->CurrentCursor);
+    ODir->CurrentPos    = DirEnt->EntryPos + 1;
+  }
+
+  *PtrDirEnt = DirEnt;
+  return EFI_SUCCESS;
+}
+
+/**
+
+  Set the directory entry count according to the filename.
+
+  @param  OFile                 - The corresponding OFile.
+  @param  DirEnt                - The directory entry to be set.
+
+**/
+STATIC
+VOID
+FatSetEntryCount (
+  IN FAT_OFILE    *OFile,
+  IN FAT_DIRENT   *DirEnt
+  )
+{
+  CHAR16  *FileString;
+  CHAR8   *File8Dot3Name;
+
+  //
+  // Get new entry count and set the 8.3 name
+  //
+  DirEnt->EntryCount  = 1;
+  FileString          = DirEnt->FileString;
+  File8Dot3Name       = DirEnt->Entry.FileName;
+  SetMem (File8Dot3Name, FAT_NAME_LEN, ' ');
+  if (StrCmp (FileString, L".") == 0) {
+    //
+    // "." entry
+    //
+    File8Dot3Name[0] = '.';
+    FatCloneDirEnt (DirEnt, OFile->DirEnt);
+  } else if (StrCmp (FileString, L"..") == 0) {
+    //
+    // ".." entry
+    //
+    File8Dot3Name[0]  = '.';
+    File8Dot3Name[1]  = '.';
+    FatCloneDirEnt (DirEnt, OFile->Parent->DirEnt);
+  } else {
+    //
+    // Normal name
+    //
+    if (FatCheckIs8Dot3Name (FileString, File8Dot3Name)) {
+      //
+      // This file name is a valid 8.3 file name, we need to further check its case flag
+      //
+      FatSetCaseFlag (DirEnt);
+    } else {
+      //
+      // The file name is not a valid 8.3 name we need to generate an 8.3 name for it
+      //
+      FatCreate8Dot3Name (OFile, DirEnt);
+      DirEnt->EntryCount = (UINT8)(LFN_ENTRY_NUMBER (StrLen (FileString)) + DirEnt->EntryCount);
+    }
+  }
+}
+
+/**
+
+  Append a zero cluster to the current OFile.
+
+  @param  OFile        - The directory OFile which needs to be updated.
+
+  @retval EFI_SUCCESS  - Append a zero cluster to the OFile successfully.
+  @return other        - An error occurred when appending the zero cluster.
+
+**/
+STATIC
+EFI_STATUS
+FatExpandODir (
+  IN FAT_OFILE  *OFile
+  )
+{
+  return FatExpandOFile (OFile, OFile->FileSize + OFile->Volume->ClusterSize);
+}
+
+/**
+
+  Search the Root OFile for the possible volume label.
+
+  @param  Root                  - The Root OFile.
+  @param  DirEnt                - The returned directory entry of volume label.
+
+  @retval EFI_SUCCESS           - The search process is completed successfully.
+  @return other                 - An error occurred when searching volume label.
+
+**/
+STATIC
+EFI_STATUS
+FatSeekVolumeId (
+  IN  FAT_OFILE            *Root,
+  OUT FAT_DIRENT           *DirEnt
+  )
+{
+  EFI_STATUS          Status;
+  UINTN               EntryPos;
+  FAT_DIRECTORY_ENTRY *Entry;
+
+  EntryPos        = 0;
+  Entry           = &DirEnt->Entry;
+  DirEnt->Invalid = TRUE;
+  do {
+    Status = FatAccessEntry (Root, ReadData, EntryPos, Entry);
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+
+    if (((UINT8) Entry->FileName[0] != DELETE_ENTRY_MARK) && (((Entry->Attributes) & (~FAT_ATTRIBUTE_ARCHIVE)) == FAT_ATTRIBUTE_VOLUME_ID)) {
+      DirEnt->EntryPos   = (UINT16) EntryPos;
+      DirEnt->EntryCount = 1;
+      DirEnt->Invalid    = FALSE;
+      break;
+    }
+
+    EntryPos++;
+  } while (Entry->FileName[0] != EMPTY_ENTRY_MARK);
+  return EFI_SUCCESS;
+}
+
+/**
+
+  Use First Fit Algorithm to insert directory entry.
+  Only this function will erase "E5" entries in a directory.
+  In view of safest recovery, this function will only be triggered
+  when maximum directory entry number has reached.
+
+  @param  OFile                 - The corresponding OFile.
+  @param  DirEnt                - The directory entry to be inserted.
+
+  @retval EFI_SUCCESS           - The directory entry has been successfully inserted.
+  @retval EFI_VOLUME_FULL       - The directory can not hold more directory entries.
+  @return Others                - Some error occurred when inserting new directory entries.
+
+**/
+STATIC
+EFI_STATUS
+FatFirstFitInsertDirEnt (
+  IN FAT_OFILE    *OFile,
+  IN FAT_DIRENT   *DirEnt
+  )
+{
+  EFI_STATUS      Status;
+  FAT_ODIR        *ODir;
+  LIST_ENTRY      *CurrentEntry;
+  FAT_DIRENT      *CurrentDirEnt;
+  UINT32          CurrentPos;
+  UINT32          LabelPos;
+  UINT32          NewEntryPos;
+  UINT16          EntryCount;
+  FAT_DIRENT      LabelDirEnt;
+
+  LabelPos = 0;
+  if (OFile->Parent == NULL) {
+    Status = FatSeekVolumeId (OFile, &LabelDirEnt);
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+
+    if (!LabelDirEnt.Invalid) {
+      LabelPos = LabelDirEnt.EntryPos;
+    }
+  }
+
+  EntryCount  = DirEnt->EntryCount;
+  NewEntryPos = EntryCount;
+  CurrentPos  = 0;
+  ODir        = OFile->ODir;
+  for (CurrentEntry = ODir->ChildList.ForwardLink;
+       CurrentEntry != &ODir->ChildList;
+       CurrentEntry = CurrentEntry->ForwardLink
+      ) {
+    CurrentDirEnt = DIRENT_FROM_LINK (CurrentEntry);
+    if (NewEntryPos + CurrentDirEnt->EntryCount <= CurrentDirEnt->EntryPos) {
+      if (LabelPos > NewEntryPos || LabelPos <= CurrentPos) {
+        //
+        // first fit succeeded
+        //
+        goto Done;
+      }
+    }
+
+    CurrentPos  = CurrentDirEnt->EntryPos;
+    NewEntryPos = CurrentPos + EntryCount;
+  }
+
+  if (NewEntryPos >= ODir->CurrentEndPos) {
+    return EFI_VOLUME_FULL;
+  }
+
+Done:
+  DirEnt->EntryPos   = (UINT16) NewEntryPos;
+  DirEnt->Link.BackLink = CurrentEntry;
+  return EFI_SUCCESS;
+}
+
+/**
+
+  Find the new directory entry position for the directory entry.
+
+  @param  OFile                 - The corresponding OFile.
+  @param  DirEnt                - The directory entry whose new position is to be set.
+
+  @retval EFI_SUCCESS           - The new directory entry position is successfully found.
+  @retval EFI_VOLUME_FULL       - The directory has reach its maximum capacity.
+  @return other                 - An error occurred when reading the directory entry.
+
+**/
+STATIC
+EFI_STATUS
+FatNewEntryPos (
+  IN FAT_OFILE    *OFile,
+  IN FAT_DIRENT   *DirEnt
+  )
+{
+  EFI_STATUS  Status;
+  FAT_ODIR    *ODir;
+  FAT_DIRENT  *TempDirEnt;
+  UINT32      NewEndPos;
+
+  ODir = OFile->ODir;
+  ASSERT (ODir != NULL);
+  //
+  // Make sure the whole directory has been loaded
+  //
+  while (!ODir->EndOfDir) {
+    Status = FatLoadNextDirEnt (OFile, &TempDirEnt);
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+  }
+  //
+  // We will append this entry to the end of directory
+  //
+  FatGetCurrentFatTime (&DirEnt->Entry.FileCreateTime);
+  CopyMem (&DirEnt->Entry.FileModificationTime, &DirEnt->Entry.FileCreateTime, sizeof (FAT_DATE_TIME));
+  CopyMem (&DirEnt->Entry.FileLastAccess, &DirEnt->Entry.FileCreateTime.Date, sizeof (FAT_DATE));
+  NewEndPos = ODir->CurrentEndPos + DirEnt->EntryCount;
+  if (NewEndPos * sizeof (FAT_DIRECTORY_ENTRY) > OFile->FileSize) {
+    if (NewEndPos >= (OFile->IsFixedRootDir ? OFile->Volume->RootEntries : FAT_MAX_DIRENTRY_COUNT)) {
+      //
+      // We try to use fist fit algorithm to insert this directory entry
+      //
+      return FatFirstFitInsertDirEnt (OFile, DirEnt);
+    }
+    //
+    // We should allocate a new cluster for this directory
+    //
+    Status = FatExpandODir (OFile);
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+  }
+  //
+  // We append our directory entry at the end of directory file
+  //
+  ODir->CurrentEndPos = NewEndPos;
+  DirEnt->EntryPos = (UINT16) (ODir->CurrentEndPos - 1);
+  return EFI_SUCCESS;
+}
+
+/**
+
+  Get the directory entry for the volume.
+
+  @param  Volume                - FAT file system volume.
+  @param  Name                  - The file name of the volume.
+
+  @retval EFI_SUCCESS           - Update the volume with the directory entry successfully.
+  @return others                - An error occurred when getting volume label.
+
+**/
+EFI_STATUS
+FatGetVolumeEntry (
+  IN FAT_VOLUME           *Volume,
+  IN CHAR16               *Name
+  )
+{
+  EFI_STATUS  Status;
+  FAT_DIRENT  LabelDirEnt;
+
+  *Name   = 0;
+  Status  = FatSeekVolumeId (Volume->Root, &LabelDirEnt);
+  if (!EFI_ERROR (Status)) {
+    if (!LabelDirEnt.Invalid) {
+      FatNameToStr (LabelDirEnt.Entry.FileName, FAT_NAME_LEN, FALSE, Name);
+    }
+  }
+
+  return Status;
+}
+
+/**
+
+  Set the relevant directory entry into disk for the volume.
+
+  @param  Volume              - FAT file system volume.
+  @param  Name                - The new file name of the volume.
+
+  @retval EFI_SUCCESS         - Update the Volume successfully.
+  @retval EFI_UNSUPPORTED     - The input label is not a valid volume label.
+  @return other               - An error occurred when setting volume label.
+
+**/
+EFI_STATUS
+FatSetVolumeEntry (
+  IN FAT_VOLUME           *Volume,
+  IN CHAR16               *Name
+  )
+{
+  EFI_STATUS  Status;
+  FAT_DIRENT  LabelDirEnt;
+  FAT_OFILE   *Root;
+
+  Root    = Volume->Root;
+  Status  = FatSeekVolumeId (Volume->Root, &LabelDirEnt);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  if (LabelDirEnt.Invalid) {
+    //
+    // If there is not the relevant directory entry, create a new one
+    //
+    ZeroMem (&LabelDirEnt, sizeof (FAT_DIRENT));
+    LabelDirEnt.EntryCount = 1;
+    Status                 = FatNewEntryPos (Root, &LabelDirEnt);
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+
+    LabelDirEnt.Entry.Attributes = FAT_ATTRIBUTE_VOLUME_ID;
+  }
+
+  SetMem (LabelDirEnt.Entry.FileName, FAT_NAME_LEN, ' ');
+  if (FatStrToFat (Name, FAT_NAME_LEN, LabelDirEnt.Entry.FileName)) {
+    return EFI_UNSUPPORTED;
+  }
+
+  FatGetCurrentFatTime (&LabelDirEnt.Entry.FileModificationTime);
+  return FatStoreDirEnt (Root, &LabelDirEnt);
+}
+
+/**
+
+  Create "." and ".." directory entries in the newly-created parent OFile.
+
+  @param  OFile                 - The parent OFile.
+
+  @retval EFI_SUCCESS           - The dot directory entries are successfully created.
+  @return other                 - An error occurred when creating the directory entry.
+
+**/
+EFI_STATUS
+FatCreateDotDirEnts (
+  IN FAT_OFILE          *OFile
+  )
+{
+  EFI_STATUS  Status;
+  FAT_DIRENT  *DirEnt;
+
+  Status = FatExpandODir (OFile);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  FatSetDirEntCluster (OFile);
+  //
+  // Create "."
+  //
+  Status = FatCreateDirEnt (OFile, L".", FAT_ATTRIBUTE_DIRECTORY, &DirEnt);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  //
+  // Create ".."
+  //
+  Status = FatCreateDirEnt (OFile, L"..", FAT_ATTRIBUTE_DIRECTORY, &DirEnt);
+  return Status;
+}
+
+/**
+
+  Create a directory entry in the parent OFile.
+
+  @param  OFile                 - The parent OFile.
+  @param  FileName              - The filename of the newly-created directory entry.
+  @param  Attributes            - The attribute of the newly-created directory entry.
+  @param  PtrDirEnt             - The pointer to the newly-created directory entry.
+
+  @retval EFI_SUCCESS           - The directory entry is successfully created.
+  @retval EFI_OUT_OF_RESOURCES  - Not enough memory to create the directory entry.
+  @return other                 - An error occurred when creating the directory entry.
+
+**/
+EFI_STATUS
+FatCreateDirEnt (
+  IN  FAT_OFILE         *OFile,
+  IN  CHAR16            *FileName,
+  IN  UINT8             Attributes,
+  OUT FAT_DIRENT        **PtrDirEnt
+  )
+{
+  FAT_DIRENT  *DirEnt;
+  FAT_ODIR    *ODir;
+  EFI_STATUS  Status;
+
+  ASSERT (OFile != NULL);
+  ODir = OFile->ODir;
+  ASSERT (ODir != NULL);
+  DirEnt = AllocateZeroPool (sizeof (FAT_DIRENT));
+  if (DirEnt == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  DirEnt->Signature   = FAT_DIRENT_SIGNATURE;
+  DirEnt->FileString  = AllocateCopyPool (StrSize (FileName), FileName);
+  if (DirEnt->FileString == NULL) {
+    Status = EFI_OUT_OF_RESOURCES;
+    goto Done;
+  }
+  //
+  // Determine how many directory entries we need
+  //
+  FatSetEntryCount (OFile, DirEnt);
+  //
+  // Determine the file's directory entry position
+  //
+  Status = FatNewEntryPos (OFile, DirEnt);
+  if (EFI_ERROR (Status)) {
+    goto Done;
+  }
+
+  FatAddDirEnt (ODir, DirEnt);
+  DirEnt->Entry.Attributes = Attributes;
+  *PtrDirEnt               = DirEnt;
+  DEBUG ((EFI_D_INFO, "FSOpen: Created new directory entry '%S'\n", DirEnt->FileString));
+  return FatStoreDirEnt (OFile, DirEnt);
+
+Done:
+  FatFreeDirEnt (DirEnt);
+  return Status;
+}
+
+/**
+
+  Remove this directory entry node from the list of directory entries and hash table.
+
+  @param  OFile                - The parent OFile.
+  @param  DirEnt               - The directory entry to be removed.
+
+  @retval EFI_SUCCESS          - The directory entry is successfully removed.
+  @return other                - An error occurred when removing the directory entry.
+
+**/
+EFI_STATUS
+FatRemoveDirEnt (
+  IN FAT_OFILE    *OFile,
+  IN FAT_DIRENT   *DirEnt
+  )
+{
+  FAT_ODIR  *ODir;
+
+  ODir = OFile->ODir;
+  if (ODir->CurrentCursor == &DirEnt->Link) {
+    //
+    // Move the directory cursor to its previous directory entry
+    //
+    ODir->CurrentCursor = ODir->CurrentCursor->BackLink;
+  }
+  //
+  // Remove from directory entry list
+  //
+  RemoveEntryList (&DirEnt->Link);
+  //
+  // Remove from hash table
+  //
+  FatDeleteFromHashTable (ODir, DirEnt);
+  DirEnt->Entry.FileName[0] = DELETE_ENTRY_MARK;
+  DirEnt->Invalid           = TRUE;
+  return FatStoreDirEnt (OFile, DirEnt);
+}
+
+/**
+
+  Open the directory entry to get the OFile.
+
+  @param  Parent                - The parent OFile.
+  @param  DirEnt                - The directory entry to be opened.
+
+  @retval EFI_SUCCESS           - The directory entry is successfully opened.
+  @retval EFI_OUT_OF_RESOURCES  - not enough memory to allocate a new OFile.
+  @return other                 - An error occurred when opening the directory entry.
+
+**/
+EFI_STATUS
+FatOpenDirEnt (
+  IN FAT_OFILE         *Parent,
+  IN FAT_DIRENT        *DirEnt
+  )
+{
+  FAT_OFILE   *OFile;
+  FAT_VOLUME  *Volume;
+
+  if (DirEnt->OFile == NULL) {
+    //
+    // Open the directory entry
+    //
+    OFile = AllocateZeroPool (sizeof (FAT_OFILE));
+    if (OFile == NULL) {
+      return EFI_OUT_OF_RESOURCES;
+    }
+
+    OFile->Signature = FAT_OFILE_SIGNATURE;
+    InitializeListHead (&OFile->Opens);
+    InitializeListHead (&OFile->ChildHead);
+    OFile->Parent = Parent;
+    OFile->DirEnt = DirEnt;
+    if (Parent != NULL) {
+      //
+      // The newly created OFile is not root
+      //
+      Volume             = Parent->Volume;
+      OFile->FullPathLen = Parent->FullPathLen + 1 + StrLen (DirEnt->FileString);
+      OFile->FileCluster = ((DirEnt->Entry.FileClusterHigh) << 16) | (DirEnt->Entry.FileCluster);
+      InsertTailList (&Parent->ChildHead, &OFile->ChildLink);
+    } else {
+      //
+      // The newly created OFile is root
+      //
+      Volume                = VOLUME_FROM_ROOT_DIRENT (DirEnt);
+      Volume->Root          = OFile;
+      OFile->FileCluster    = Volume->RootCluster;
+      if (Volume->FatType  != Fat32) {
+        OFile->IsFixedRootDir  = TRUE;
+      }
+    }
+
+    OFile->FileCurrentCluster  = OFile->FileCluster;
+    OFile->Volume              = Volume;
+    InsertHeadList (&Volume->CheckRef, &OFile->CheckLink);
+
+    OFile->FileSize = DirEnt->Entry.FileSize;
+    if ((DirEnt->Entry.Attributes & FAT_ATTRIBUTE_DIRECTORY) != 0) {
+      if (OFile->IsFixedRootDir) {
+        OFile->FileSize = Volume->RootEntries * sizeof (FAT_DIRECTORY_ENTRY);
+      } else {
+        OFile->FileSize = FatPhysicalDirSize (Volume, OFile->FileCluster);
+      }
+
+      FatRequestODir (OFile);
+      if (OFile->ODir == NULL) {
+        return EFI_OUT_OF_RESOURCES;
+      }
+    }
+
+    DirEnt->OFile = OFile;
+  }
+
+  return EFI_SUCCESS;
+}
+
+/**
+
+  Close the directory entry and free the OFile.
+
+  @param  DirEnt               - The directory entry to be closed.
+
+**/
+VOID
+FatCloseDirEnt (
+  IN FAT_DIRENT        *DirEnt
+  )
+{
+  FAT_OFILE   *OFile;
+  FAT_VOLUME  *Volume;
+
+  OFile   = DirEnt->OFile;
+  ASSERT (OFile != NULL);
+  Volume  = OFile->Volume;
+
+  if (OFile->ODir != NULL) {
+    FatDiscardODir (OFile);
+  }
+
+  if (OFile->Parent == NULL) {
+    Volume->Root = NULL;
+  } else {
+    RemoveEntryList (&OFile->ChildLink);
+  }
+
+  FreePool (OFile);
+  DirEnt->OFile = NULL;
+  if (DirEnt->Invalid == TRUE) {
+    //
+    // Free directory entry itself
+    //
+    FatFreeDirEnt (DirEnt);
+  }
+}
+
+/**
+
+  Traverse filename and open all OFiles that can be opened.
+  Update filename pointer to the component that can't be opened.
+  If more than one name component remains, returns an error;
+  otherwise, return the remaining name component so that the caller might choose to create it.
+
+  @param  PtrOFile              - As input, the reference OFile; as output, the located OFile.
+  @param  FileName              - The file name relevant to the OFile.
+  @param  Attributes            - The attribute of the destination OFile.
+  @param  NewFileName           - The remaining file name.
+
+  @retval EFI_NOT_FOUND         - The file name can't be opened and there is more than one
+                          components within the name left (this means the name can
+                          not be created either).
+  @retval EFI_INVALID_PARAMETER - The parameter is not valid.
+  @retval EFI_SUCCESS           - Open the file successfully.
+  @return other                 - An error occurred when locating the OFile.
+
+**/
+EFI_STATUS
+FatLocateOFile (
+  IN OUT FAT_OFILE        **PtrOFile,
+  IN     CHAR16           *FileName,
+  IN     UINT8            Attributes,
+     OUT CHAR16           *NewFileName
+  )
+{
+  EFI_STATUS  Status;
+  FAT_VOLUME  *Volume;
+  CHAR16      ComponentName[EFI_PATH_STRING_LENGTH];
+  UINTN       FileNameLen;
+  BOOLEAN     DirIntended;
+  CHAR16      *Next;
+  FAT_OFILE   *OFile;
+  FAT_DIRENT  *DirEnt;
+
+  DirEnt = NULL;
+
+  FileNameLen = StrLen (FileName);
+  if (FileNameLen == 0) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  OFile       = *PtrOFile;
+  Volume      = OFile->Volume;
+
+  DirIntended = FALSE;
+  if (FileName[FileNameLen - 1] == PATH_NAME_SEPARATOR) {
+    DirIntended = TRUE;
+  }
+  //
+  // If name starts with path name separator, then move to root OFile
+  //
+  if (*FileName == PATH_NAME_SEPARATOR) {
+    OFile = Volume->Root;
+    FileName++;
+    FileNameLen--;
+  }
+  //
+  // Per FAT Spec the file name should meet the following criteria:
+  //   C1. Length (FileLongName) <= 255
+  //   C2. Length (X:FileFullPath<NUL>) <= 260
+  // Here we check C2 first.
+  //
+  if (2 + OFile->FullPathLen + 1 + FileNameLen + 1 > EFI_PATH_STRING_LENGTH) {
+    //
+    // Full path length can not surpass 256
+    //
+    return EFI_INVALID_PARAMETER;
+  }
+  //
+  // Start at current location
+  //
+  Next = FileName;
+  for (;;) {
+    //
+    // Get the next component name
+    //
+    FileName = Next;
+    Next     = FatGetNextNameComponent (FileName, ComponentName);
+
+    //
+    // If end of the file name, we're done
+    //
+    if (ComponentName[0] == 0) {
+      if (DirIntended && OFile->ODir == NULL) {
+        return EFI_NOT_FOUND;
+      }
+
+      NewFileName[0] = 0;
+      break;
+    }
+    //
+    // If "dot", then current
+    //
+    if (StrCmp (ComponentName, L".") == 0) {
+      continue;
+    }
+    //
+    // If "dot dot", then parent
+    //
+    if (StrCmp (ComponentName, L"..") == 0) {
+      if (OFile->Parent == NULL) {
+        return EFI_INVALID_PARAMETER;
+      }
+      OFile = OFile->Parent;
+      continue;
+    }
+
+    if (!FatFileNameIsValid (ComponentName, NewFileName)) {
+      return EFI_INVALID_PARAMETER;
+    }
+    //
+    // We have a component name, try to open it
+    //
+    if (OFile->ODir == NULL) {
+      //
+      // This file isn't a directory, can't open it
+      //
+      return EFI_NOT_FOUND;
+    }
+    //
+    // Search the compName in the directory
+    //
+    Status = FatSearchODir (OFile, NewFileName, &DirEnt);
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+
+    if (DirEnt == NULL) {
+      //
+      // component name is not found in the directory
+      //
+      if (*Next != 0) {
+        return EFI_NOT_FOUND;
+      }
+
+      if (DirIntended && (Attributes & FAT_ATTRIBUTE_DIRECTORY) == 0) {
+        return EFI_INVALID_PARAMETER;
+      }
+      //
+      // It's the last component name - return with the open
+      // path and the remaining name
+      //
+      break;
+    }
+
+    Status = FatOpenDirEnt (OFile, DirEnt);
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+
+    OFile = DirEnt->OFile;
+  }
+
+  *PtrOFile = OFile;
+  return EFI_SUCCESS;
+}
+
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/DiskCache.c b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/DiskCache.c
new file mode 100644
index 00000000..51ab9d3e
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/DiskCache.c
@@ -0,0 +1,489 @@
+/** @file
+  Cache implementation for EFI FAT File system driver.
+
+Copyright (c) 2005 - 2013, Intel Corporation. All rights reserved.<BR>
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "Fat.h"
+
+/**
+
+  This function is used by the Data Cache.
+
+  When this function is called by write command, all entries in this range
+  are older than the contents in disk, so they are invalid; just mark them invalid.
+
+  When this function is called by read command, if any entry in this range
+  is dirty, it means that the relative info directly read from media is older than
+  than the info in the cache; So need to update the relative info in the Buffer.
+
+  @param  Volume                - FAT file system volume.
+  @param  IoMode                - This function is called by read command or write command
+  @param  StartPageNo           - First PageNo to be checked in the cache.
+  @param  EndPageNo             - Last PageNo to be checked in the cache.
+  @param  Buffer                - The user buffer need to update. Only when doing the read command
+                          and there is dirty cache in the cache range, this parameter will be used.
+
+**/
+STATIC
+VOID
+FatFlushDataCacheRange (
+  IN  FAT_VOLUME         *Volume,
+  IN  IO_MODE            IoMode,
+  IN  UINTN              StartPageNo,
+  IN  UINTN              EndPageNo,
+  OUT UINT8              *Buffer
+  )
+{
+  UINTN       PageNo;
+  UINTN       GroupNo;
+  UINTN       GroupMask;
+  UINTN       PageSize;
+  UINT8       PageAlignment;
+  DISK_CACHE  *DiskCache;
+  CACHE_TAG   *CacheTag;
+  UINT8       *BaseAddress;
+
+  DiskCache     = &Volume->DiskCache[CacheData];
+  BaseAddress   = DiskCache->CacheBase;
+  GroupMask     = DiskCache->GroupMask;
+  PageAlignment = DiskCache->PageAlignment;
+  PageSize      = (UINTN)1 << PageAlignment;
+
+  for (PageNo = StartPageNo; PageNo < EndPageNo; PageNo++) {
+    GroupNo   = PageNo & GroupMask;
+    CacheTag  = &DiskCache->CacheTag[GroupNo];
+    if (CacheTag->RealSize > 0 && CacheTag->PageNo == PageNo) {
+      //
+      // When reading data form disk directly, if some dirty data
+      // in cache is in this rang, this data in the Buffer need to
+      // be updated with the cache's dirty data.
+      //
+      if (IoMode == ReadDisk) {
+        if (CacheTag->Dirty) {
+          CopyMem (
+            Buffer + ((PageNo - StartPageNo) << PageAlignment),
+            BaseAddress + (GroupNo << PageAlignment),
+            PageSize
+            );
+        }
+      } else {
+        //
+        // Make all valid entries in this range invalid.
+        //
+        CacheTag->RealSize = 0;
+      }
+    }
+  }
+}
+
+/**
+
+  Exchange the cache page with the image on the disk
+
+  @param  Volume                - FAT file system volume.
+  @param  DataType              - Indicate the cache type.
+  @param  IoMode                - Indicate whether to load this page from disk or store this page to disk.
+  @param  CacheTag              - The Cache Tag for the current cache page.
+  @param  Task                    point to task instance.
+
+  @retval EFI_SUCCESS           - Cache page exchanged successfully.
+  @return Others                - An error occurred when exchanging cache page.
+
+**/
+STATIC
+EFI_STATUS
+FatExchangeCachePage (
+  IN FAT_VOLUME         *Volume,
+  IN CACHE_DATA_TYPE    DataType,
+  IN IO_MODE            IoMode,
+  IN CACHE_TAG          *CacheTag,
+  IN FAT_TASK           *Task
+  )
+{
+  EFI_STATUS  Status;
+  UINTN       GroupNo;
+  UINTN       PageNo;
+  UINTN       WriteCount;
+  UINTN       RealSize;
+  UINT64      EntryPos;
+  UINT64      MaxSize;
+  DISK_CACHE  *DiskCache;
+  VOID        *PageAddress;
+  UINT8       PageAlignment;
+
+  DiskCache     = &Volume->DiskCache[DataType];
+  PageNo        = CacheTag->PageNo;
+  GroupNo       = PageNo & DiskCache->GroupMask;
+  PageAlignment = DiskCache->PageAlignment;
+  PageAddress   = DiskCache->CacheBase + (GroupNo << PageAlignment);
+  EntryPos      = DiskCache->BaseAddress + LShiftU64 (PageNo, PageAlignment);
+  RealSize      = CacheTag->RealSize;
+  if (IoMode == ReadDisk) {
+    RealSize  = (UINTN)1 << PageAlignment;
+    MaxSize   = DiskCache->LimitAddress - EntryPos;
+    if (MaxSize < RealSize) {
+      DEBUG ((EFI_D_INFO, "FatDiskIo: Cache Page OutBound occurred! \n"));
+      RealSize = (UINTN) MaxSize;
+    }
+  }
+
+  WriteCount = 1;
+  if (DataType == CacheFat && IoMode == WriteDisk) {
+    WriteCount = Volume->NumFats;
+  }
+
+  do {
+    //
+    // Only fat table writing will execute more than once
+    //
+    Status = FatDiskIo (Volume, IoMode, EntryPos, RealSize, PageAddress, Task);
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+
+    EntryPos += Volume->FatSize;
+  } while (--WriteCount > 0);
+
+  CacheTag->Dirty     = FALSE;
+  CacheTag->RealSize  = RealSize;
+  return EFI_SUCCESS;
+}
+
+/**
+
+  Get one cache page by specified PageNo.
+
+  @param  Volume                - FAT file system volume.
+  @param  CacheDataType         - The cache type: CACHE_FAT or CACHE_DATA.
+  @param  PageNo                - PageNo to match with the cache.
+  @param  CacheTag              - The Cache Tag for the current cache page.
+
+  @retval EFI_SUCCESS           - Get the cache page successfully.
+  @return other                 - An error occurred when accessing data.
+
+**/
+STATIC
+EFI_STATUS
+FatGetCachePage (
+  IN FAT_VOLUME         *Volume,
+  IN CACHE_DATA_TYPE    CacheDataType,
+  IN UINTN              PageNo,
+  IN CACHE_TAG          *CacheTag
+  )
+{
+  EFI_STATUS  Status;
+  UINTN       OldPageNo;
+
+  OldPageNo = CacheTag->PageNo;
+  if (CacheTag->RealSize > 0 && OldPageNo == PageNo) {
+    //
+    // Cache Hit occurred
+    //
+    return EFI_SUCCESS;
+  }
+
+  //
+  // Write dirty cache page back to disk
+  //
+  if (CacheTag->RealSize > 0 && CacheTag->Dirty) {
+    Status = FatExchangeCachePage (Volume, CacheDataType, WriteDisk, CacheTag, NULL);
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+  }
+  //
+  // Load new data from disk;
+  //
+  CacheTag->PageNo  = PageNo;
+  Status            = FatExchangeCachePage (Volume, CacheDataType, ReadDisk, CacheTag, NULL);
+
+  return Status;
+}
+
+/**
+
+  Read Length bytes from the position of Offset into Buffer, or
+  write Length bytes from Buffer into the position of Offset.
+
+  @param  Volume                - FAT file system volume.
+  @param  CacheDataType         - The type of cache: CACHE_DATA or CACHE_FAT.
+  @param  IoMode                - Indicate the type of disk access.
+  @param  PageNo                - The number of unaligned cache page.
+  @param  Offset                - The starting byte of cache page.
+  @param  Length                - The number of bytes that is read or written
+  @param  Buffer                - Buffer containing cache data.
+
+  @retval EFI_SUCCESS           - The data was accessed correctly.
+  @return Others                - An error occurred when accessing unaligned cache page.
+
+**/
+STATIC
+EFI_STATUS
+FatAccessUnalignedCachePage (
+  IN     FAT_VOLUME        *Volume,
+  IN     CACHE_DATA_TYPE   CacheDataType,
+  IN     IO_MODE           IoMode,
+  IN     UINTN             PageNo,
+  IN     UINTN             Offset,
+  IN     UINTN             Length,
+  IN OUT VOID              *Buffer
+  )
+{
+  EFI_STATUS  Status;
+  VOID        *Source;
+  VOID        *Destination;
+  DISK_CACHE  *DiskCache;
+  CACHE_TAG   *CacheTag;
+  UINTN       GroupNo;
+
+  DiskCache = &Volume->DiskCache[CacheDataType];
+  GroupNo   = PageNo & DiskCache->GroupMask;
+  CacheTag  = &DiskCache->CacheTag[GroupNo];
+  Status    = FatGetCachePage (Volume, CacheDataType, PageNo, CacheTag);
+  if (!EFI_ERROR (Status)) {
+    Source      = DiskCache->CacheBase + (GroupNo << DiskCache->PageAlignment) + Offset;
+    Destination = Buffer;
+    if (IoMode != ReadDisk) {
+      CacheTag->Dirty   = TRUE;
+      DiskCache->Dirty  = TRUE;
+      Destination       = Source;
+      Source            = Buffer;
+    }
+
+    CopyMem (Destination, Source, Length);
+  }
+
+  return Status;
+}
+
+/**
+
+  Read BufferSize bytes from the position of Offset into Buffer,
+  or write BufferSize bytes from Buffer into the position of Offset.
+
+  Base on the parameter of CACHE_DATA_TYPE, the data access will be divided into
+  the access of FAT cache (CACHE_FAT) and the access of Data cache (CACHE_DATA):
+
+  1. Access of FAT cache (CACHE_FAT): Access the data in the FAT cache, if there is cache
+     page hit, just return the cache page; else update the related cache page and return
+     the right cache page.
+  2. Access of Data cache (CACHE_DATA):
+     The access data will be divided into UnderRun data, Aligned data and OverRun data;
+     The UnderRun data and OverRun data will be accessed by the Data cache,
+     but the Aligned data will be accessed with disk directly.
+
+  @param  Volume                - FAT file system volume.
+  @param  CacheDataType         - The type of cache: CACHE_DATA or CACHE_FAT.
+  @param  IoMode                - Indicate the type of disk access.
+  @param  Offset                - The starting byte offset to read from.
+  @param  BufferSize            - Size of Buffer.
+  @param  Buffer                - Buffer containing cache data.
+  @param  Task                    point to task instance.
+
+  @retval EFI_SUCCESS           - The data was accessed correctly.
+  @retval EFI_MEDIA_CHANGED     - The MediaId does not match the current device.
+  @return Others                - An error occurred when accessing cache.
+
+**/
+EFI_STATUS
+FatAccessCache (
+  IN     FAT_VOLUME         *Volume,
+  IN     CACHE_DATA_TYPE    CacheDataType,
+  IN     IO_MODE            IoMode,
+  IN     UINT64             Offset,
+  IN     UINTN              BufferSize,
+  IN OUT UINT8              *Buffer,
+  IN     FAT_TASK           *Task
+  )
+{
+  EFI_STATUS  Status;
+  UINTN       PageSize;
+  UINTN       UnderRun;
+  UINTN       OverRun;
+  UINTN       AlignedSize;
+  UINTN       Length;
+  UINTN       PageNo;
+  UINTN       AlignedPageCount;
+  UINTN       OverRunPageNo;
+  DISK_CACHE  *DiskCache;
+  UINT64      EntryPos;
+  UINT8       PageAlignment;
+
+  ASSERT (Volume->CacheBuffer != NULL);
+
+  Status        = EFI_SUCCESS;
+  DiskCache     = &Volume->DiskCache[CacheDataType];
+  EntryPos      = Offset - DiskCache->BaseAddress;
+  PageAlignment = DiskCache->PageAlignment;
+  PageSize      = (UINTN)1 << PageAlignment;
+  PageNo        = (UINTN) RShiftU64 (EntryPos, PageAlignment);
+  UnderRun      = ((UINTN) EntryPos) & (PageSize - 1);
+
+  if (UnderRun > 0) {
+    Length = PageSize - UnderRun;
+    if (Length > BufferSize) {
+      Length = BufferSize;
+    }
+
+    Status = FatAccessUnalignedCachePage (Volume, CacheDataType, IoMode, PageNo, UnderRun, Length, Buffer);
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+
+    Buffer     += Length;
+    BufferSize -= Length;
+    PageNo++;
+  }
+
+  AlignedPageCount  = BufferSize >> PageAlignment;
+  OverRunPageNo     = PageNo + AlignedPageCount;
+  //
+  // The access of the Aligned data
+  //
+  if (AlignedPageCount > 0) {
+    //
+    // Accessing fat table cannot have alignment data
+    //
+    ASSERT (CacheDataType == CacheData);
+
+    EntryPos    = Volume->RootPos + LShiftU64 (PageNo, PageAlignment);
+    AlignedSize = AlignedPageCount << PageAlignment;
+    Status      = FatDiskIo (Volume, IoMode, EntryPos, AlignedSize, Buffer, Task);
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+    //
+    // If these access data over laps the relative cache range, these cache pages need
+    // to be updated.
+    //
+    FatFlushDataCacheRange (Volume, IoMode, PageNo, OverRunPageNo, Buffer);
+    Buffer      += AlignedSize;
+    BufferSize  -= AlignedSize;
+  }
+  //
+  // The access of the OverRun data
+  //
+  OverRun = BufferSize;
+  if (OverRun > 0) {
+    //
+    // Last read is not a complete page
+    //
+    Status = FatAccessUnalignedCachePage (Volume, CacheDataType, IoMode, OverRunPageNo, 0, OverRun, Buffer);
+  }
+
+  return Status;
+}
+
+/**
+
+  Flush all the dirty cache back, include the FAT cache and the Data cache.
+
+  @param  Volume                - FAT file system volume.
+  @param  Task                    point to task instance.
+
+  @retval EFI_SUCCESS           - Flush all the dirty cache back successfully
+  @return other                 - An error occurred when writing the data into the disk
+
+**/
+EFI_STATUS
+FatVolumeFlushCache (
+  IN FAT_VOLUME         *Volume,
+  IN FAT_TASK           *Task
+  )
+{
+  EFI_STATUS      Status;
+  CACHE_DATA_TYPE CacheDataType;
+  UINTN           GroupIndex;
+  UINTN           GroupMask;
+  DISK_CACHE      *DiskCache;
+  CACHE_TAG       *CacheTag;
+
+  for (CacheDataType = (CACHE_DATA_TYPE) 0; CacheDataType < CacheMaxType; CacheDataType++) {
+    DiskCache = &Volume->DiskCache[CacheDataType];
+    if (DiskCache->Dirty) {
+      //
+      // Data cache or fat cache is dirty, write the dirty data back
+      //
+      GroupMask = DiskCache->GroupMask;
+      for (GroupIndex = 0; GroupIndex <= GroupMask; GroupIndex++) {
+        CacheTag = &DiskCache->CacheTag[GroupIndex];
+        if (CacheTag->RealSize > 0 && CacheTag->Dirty) {
+          //
+          // Write back all Dirty Data Cache Page to disk
+          //
+          Status = FatExchangeCachePage (Volume, CacheDataType, WriteDisk, CacheTag, Task);
+          if (EFI_ERROR (Status)) {
+            return Status;
+          }
+        }
+      }
+
+      DiskCache->Dirty = FALSE;
+    }
+  }
+  //
+  // Flush the block device.
+  //
+  Status = Volume->BlockIo->FlushBlocks (Volume->BlockIo);
+  return Status;
+}
+
+/**
+
+  Initialize the disk cache according to Volume's FatType.
+
+  @param  Volume                - FAT file system volume.
+
+  @retval EFI_SUCCESS           - The disk cache is successfully initialized.
+  @retval EFI_OUT_OF_RESOURCES  - Not enough memory to allocate disk cache.
+
+**/
+EFI_STATUS
+FatInitializeDiskCache (
+  IN FAT_VOLUME         *Volume
+  )
+{
+  DISK_CACHE  *DiskCache;
+  UINTN       FatCacheGroupCount;
+  UINTN       DataCacheSize;
+  UINTN       FatCacheSize;
+  UINT8       *CacheBuffer;
+
+  DiskCache = Volume->DiskCache;
+  //
+  // Configure the parameters of disk cache
+  //
+  if (Volume->FatType == Fat12) {
+    FatCacheGroupCount                  = FAT_FATCACHE_GROUP_MIN_COUNT;
+    DiskCache[CacheFat].PageAlignment  = FAT_FATCACHE_PAGE_MIN_ALIGNMENT;
+    DiskCache[CacheData].PageAlignment = FAT_DATACACHE_PAGE_MIN_ALIGNMENT;
+  } else {
+    FatCacheGroupCount                  = FAT_FATCACHE_GROUP_MAX_COUNT;
+    DiskCache[CacheFat].PageAlignment  = FAT_FATCACHE_PAGE_MAX_ALIGNMENT;
+    DiskCache[CacheData].PageAlignment = FAT_DATACACHE_PAGE_MAX_ALIGNMENT;
+  }
+
+  DiskCache[CacheData].GroupMask     = FAT_DATACACHE_GROUP_COUNT - 1;
+  DiskCache[CacheData].BaseAddress   = Volume->RootPos;
+  DiskCache[CacheData].LimitAddress  = Volume->VolumeSize;
+  DiskCache[CacheFat].GroupMask      = FatCacheGroupCount - 1;
+  DiskCache[CacheFat].BaseAddress    = Volume->FatPos;
+  DiskCache[CacheFat].LimitAddress   = Volume->FatPos + Volume->FatSize;
+  FatCacheSize                        = FatCacheGroupCount << DiskCache[CacheFat].PageAlignment;
+  DataCacheSize                       = FAT_DATACACHE_GROUP_COUNT << DiskCache[CacheData].PageAlignment;
+  //
+  // Allocate the Fat Cache buffer
+  //
+  CacheBuffer = AllocateZeroPool (FatCacheSize + DataCacheSize);
+  if (CacheBuffer == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  Volume->CacheBuffer             = CacheBuffer;
+  DiskCache[CacheFat].CacheBase  = CacheBuffer;
+  DiskCache[CacheData].CacheBase = CacheBuffer + FatCacheSize;
+  return EFI_SUCCESS;
+}
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Fat.c b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Fat.c
new file mode 100644
index 00000000..40c5f343
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Fat.c
@@ -0,0 +1,525 @@
+/** @file
+  Fat File System driver routines that support EFI driver model.
+
+Copyright (c) 2005 - 2014, Intel Corporation. All rights reserved.<BR>
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "Fat.h"
+
+/**
+
+  Register Driver Binding protocol for this driver.
+
+  @param  ImageHandle           - Handle for the image of this driver.
+  @param  SystemTable           - Pointer to the EFI System Table.
+
+  @retval EFI_SUCCESS           - Driver loaded.
+  @return other                 - Driver not loaded.
+
+**/
+EFI_STATUS
+EFIAPI
+FatEntryPoint (
+  IN EFI_HANDLE         ImageHandle,
+  IN EFI_SYSTEM_TABLE   *SystemTable
+  );
+
+/**
+
+  Unload function for this image. Uninstall DriverBinding protocol.
+
+  @param ImageHandle           - Handle for the image of this driver.
+
+  @retval EFI_SUCCESS           - Driver unloaded successfully.
+  @return other                 - Driver can not unloaded.
+
+**/
+EFI_STATUS
+EFIAPI
+FatUnload (
+  IN EFI_HANDLE         ImageHandle
+  );
+
+/**
+
+  Test to see if this driver can add a file system to ControllerHandle.
+  ControllerHandle must support both Disk IO and Block IO protocols.
+
+  @param  This                  - Protocol instance pointer.
+  @param  ControllerHandle      - Handle of device to test.
+  @param  RemainingDevicePath   - Not used.
+
+  @retval EFI_SUCCESS           - This driver supports this device.
+  @retval EFI_ALREADY_STARTED   - This driver is already running on this device.
+  @return other                 - This driver does not support this device.
+
+**/
+EFI_STATUS
+EFIAPI
+FatDriverBindingSupported (
+  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
+  IN EFI_HANDLE                   Controller,
+  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
+  );
+
+/**
+
+  Start this driver on ControllerHandle by opening a Block IO and Disk IO
+  protocol, reading Device Path. Add a Simple File System protocol to
+  ControllerHandle if the media contains a valid file system.
+
+  @param  This                  - Protocol instance pointer.
+  @param  ControllerHandle      - Handle of device to bind driver to.
+  @param  RemainingDevicePath   - Not used.
+
+  @retval EFI_SUCCESS           - This driver is added to DeviceHandle.
+  @retval EFI_ALREADY_STARTED   - This driver is already running on DeviceHandle.
+  @retval EFI_OUT_OF_RESOURCES  - Can not allocate the memory.
+  @return other                 - This driver does not support this device.
+
+**/
+EFI_STATUS
+EFIAPI
+FatDriverBindingStart (
+  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
+  IN EFI_HANDLE                   Controller,
+  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
+  );
+
+/**
+
+  Stop this driver on ControllerHandle.
+
+  @param  This                  - Protocol instance pointer.
+  @param  ControllerHandle      - Handle of device to stop driver on.
+  @param  NumberOfChildren      - Not used.
+  @param  ChildHandleBuffer     - Not used.
+
+  @retval EFI_SUCCESS           - This driver is removed DeviceHandle.
+  @return other                 - This driver was not removed from this device.
+
+**/
+EFI_STATUS
+EFIAPI
+FatDriverBindingStop (
+  IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
+  IN  EFI_HANDLE                   Controller,
+  IN  UINTN                        NumberOfChildren,
+  IN  EFI_HANDLE                   *ChildHandleBuffer
+  );
+
+//
+// DriverBinding protocol instance
+//
+EFI_DRIVER_BINDING_PROTOCOL gFatDriverBinding = {
+  FatDriverBindingSupported,
+  FatDriverBindingStart,
+  FatDriverBindingStop,
+  0xa,
+  NULL,
+  NULL
+};
+
+/**
+
+  Register Driver Binding protocol for this driver.
+
+  @param  ImageHandle           - Handle for the image of this driver.
+  @param  SystemTable           - Pointer to the EFI System Table.
+
+  @retval EFI_SUCCESS           - Driver loaded.
+  @return other                 - Driver not loaded.
+
+**/
+EFI_STATUS
+EFIAPI
+FatEntryPoint (
+  IN EFI_HANDLE         ImageHandle,
+  IN EFI_SYSTEM_TABLE   *SystemTable
+  )
+{
+  EFI_STATUS                Status;
+
+  //
+  // Initialize the EFI Driver Library
+  //
+  Status = EfiLibInstallDriverBindingComponentName2 (
+             ImageHandle,
+             SystemTable,
+             &gFatDriverBinding,
+             ImageHandle,
+             &gFatComponentName,
+             &gFatComponentName2
+             );
+  ASSERT_EFI_ERROR (Status);
+
+  return Status;
+}
+
+/**
+
+  Unload function for this image. Uninstall DriverBinding protocol.
+
+  @param ImageHandle           - Handle for the image of this driver.
+
+  @retval EFI_SUCCESS           - Driver unloaded successfully.
+  @return other                 - Driver can not unloaded.
+
+**/
+EFI_STATUS
+EFIAPI
+FatUnload (
+  IN EFI_HANDLE  ImageHandle
+  )
+{
+  EFI_STATUS  Status;
+  EFI_HANDLE  *DeviceHandleBuffer;
+  UINTN       DeviceHandleCount;
+  UINTN       Index;
+  VOID        *ComponentName;
+  VOID        *ComponentName2;
+
+  Status = gBS->LocateHandleBuffer (
+                  AllHandles,
+                  NULL,
+                  NULL,
+                  &DeviceHandleCount,
+                  &DeviceHandleBuffer
+                  );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  for (Index = 0; Index < DeviceHandleCount; Index++) {
+    Status = EfiTestManagedDevice (DeviceHandleBuffer[Index], ImageHandle, &gEfiDiskIoProtocolGuid);
+    if (!EFI_ERROR (Status)) {
+      Status = gBS->DisconnectController (
+                      DeviceHandleBuffer[Index],
+                      ImageHandle,
+                      NULL
+                      );
+      if (EFI_ERROR (Status)) {
+        break;
+      }
+    }
+  }
+
+  if (Index == DeviceHandleCount) {
+    //
+    // Driver is stopped successfully.
+    //
+    Status = gBS->HandleProtocol (ImageHandle, &gEfiComponentNameProtocolGuid, &ComponentName);
+    if (EFI_ERROR (Status)) {
+      ComponentName = NULL;
+    }
+
+    Status = gBS->HandleProtocol (ImageHandle, &gEfiComponentName2ProtocolGuid, &ComponentName2);
+    if (EFI_ERROR (Status)) {
+      ComponentName2 = NULL;
+    }
+
+    if (ComponentName == NULL) {
+      if (ComponentName2 == NULL) {
+        Status = gBS->UninstallMultipleProtocolInterfaces (
+                        ImageHandle,
+                        &gEfiDriverBindingProtocolGuid,  &gFatDriverBinding,
+                        NULL
+                        );
+      } else {
+        Status = gBS->UninstallMultipleProtocolInterfaces (
+                        ImageHandle,
+                        &gEfiDriverBindingProtocolGuid,  &gFatDriverBinding,
+                        &gEfiComponentName2ProtocolGuid, ComponentName2,
+                        NULL
+                        );
+      }
+    } else {
+      if (ComponentName2 == NULL) {
+        Status = gBS->UninstallMultipleProtocolInterfaces (
+                        ImageHandle,
+                        &gEfiDriverBindingProtocolGuid,  &gFatDriverBinding,
+                        &gEfiComponentNameProtocolGuid,  ComponentName,
+                        NULL
+                        );
+      } else {
+        Status = gBS->UninstallMultipleProtocolInterfaces (
+                        ImageHandle,
+                        &gEfiDriverBindingProtocolGuid,  &gFatDriverBinding,
+                        &gEfiComponentNameProtocolGuid,  ComponentName,
+                        &gEfiComponentName2ProtocolGuid, ComponentName2,
+                        NULL
+                        );
+      }
+    }
+  }
+
+  if (DeviceHandleBuffer != NULL) {
+    FreePool (DeviceHandleBuffer);
+  }
+
+  return Status;
+}
+
+/**
+
+  Test to see if this driver can add a file system to ControllerHandle.
+  ControllerHandle must support both Disk IO and Block IO protocols.
+
+  @param  This                  - Protocol instance pointer.
+  @param  ControllerHandle      - Handle of device to test.
+  @param  RemainingDevicePath   - Not used.
+
+  @retval EFI_SUCCESS           - This driver supports this device.
+  @retval EFI_ALREADY_STARTED   - This driver is already running on this device.
+  @return other                 - This driver does not support this device.
+
+**/
+EFI_STATUS
+EFIAPI
+FatDriverBindingSupported (
+  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
+  IN EFI_HANDLE                   ControllerHandle,
+  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
+  )
+{
+  EFI_STATUS            Status;
+  EFI_DISK_IO_PROTOCOL  *DiskIo;
+
+  //
+  // Open the IO Abstraction(s) needed to perform the supported test
+  //
+  Status = gBS->OpenProtocol (
+                  ControllerHandle,
+                  &gEfiDiskIoProtocolGuid,
+                  (VOID **) &DiskIo,
+                  This->DriverBindingHandle,
+                  ControllerHandle,
+                  EFI_OPEN_PROTOCOL_BY_DRIVER
+                  );
+
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  //
+  // Close the I/O Abstraction(s) used to perform the supported test
+  //
+  gBS->CloseProtocol (
+         ControllerHandle,
+         &gEfiDiskIoProtocolGuid,
+         This->DriverBindingHandle,
+         ControllerHandle
+         );
+
+  //
+  // Open the IO Abstraction(s) needed to perform the supported test
+  //
+  Status = gBS->OpenProtocol (
+                  ControllerHandle,
+                  &gEfiBlockIoProtocolGuid,
+                  NULL,
+                  This->DriverBindingHandle,
+                  ControllerHandle,
+                  EFI_OPEN_PROTOCOL_TEST_PROTOCOL
+                  );
+
+  return Status;
+}
+
+/**
+
+  Start this driver on ControllerHandle by opening a Block IO and Disk IO
+  protocol, reading Device Path. Add a Simple File System protocol to
+  ControllerHandle if the media contains a valid file system.
+
+  @param  This                  - Protocol instance pointer.
+  @param  ControllerHandle      - Handle of device to bind driver to.
+  @param  RemainingDevicePath   - Not used.
+
+  @retval EFI_SUCCESS           - This driver is added to DeviceHandle.
+  @retval EFI_ALREADY_STARTED   - This driver is already running on DeviceHandle.
+  @retval EFI_OUT_OF_RESOURCES  - Can not allocate the memory.
+  @return other                 - This driver does not support this device.
+
+**/
+EFI_STATUS
+EFIAPI
+FatDriverBindingStart (
+  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
+  IN EFI_HANDLE                   ControllerHandle,
+  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
+  )
+{
+  EFI_STATUS            Status;
+  EFI_BLOCK_IO_PROTOCOL *BlockIo;
+  EFI_DISK_IO_PROTOCOL  *DiskIo;
+  EFI_DISK_IO2_PROTOCOL *DiskIo2;
+  BOOLEAN               LockedByMe;
+
+  LockedByMe = FALSE;
+  //
+  // Acquire the lock.
+  // If caller has already acquired the lock, cannot lock it again.
+  //
+  Status = FatAcquireLockOrFail ();
+  if (!EFI_ERROR (Status)) {
+    LockedByMe = TRUE;
+  }
+
+  Status = InitializeUnicodeCollationSupport (This->DriverBindingHandle);
+  if (EFI_ERROR (Status)) {
+    goto Exit;
+  }
+  //
+  // Open our required BlockIo and DiskIo
+  //
+  Status = gBS->OpenProtocol (
+                  ControllerHandle,
+                  &gEfiBlockIoProtocolGuid,
+                  (VOID **) &BlockIo,
+                  This->DriverBindingHandle,
+                  ControllerHandle,
+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
+                  );
+  if (EFI_ERROR (Status)) {
+    goto Exit;
+  }
+
+  Status = gBS->OpenProtocol (
+                  ControllerHandle,
+                  &gEfiDiskIoProtocolGuid,
+                  (VOID **) &DiskIo,
+                  This->DriverBindingHandle,
+                  ControllerHandle,
+                  EFI_OPEN_PROTOCOL_BY_DRIVER
+                  );
+  if (EFI_ERROR (Status)) {
+    goto Exit;
+  }
+
+  Status = gBS->OpenProtocol (
+                  ControllerHandle,
+                  &gEfiDiskIo2ProtocolGuid,
+                  (VOID **) &DiskIo2,
+                  This->DriverBindingHandle,
+                  ControllerHandle,
+                  EFI_OPEN_PROTOCOL_BY_DRIVER
+                  );
+  if (EFI_ERROR (Status)) {
+    DiskIo2 = NULL;
+  }
+
+  //
+  // Allocate Volume structure. In FatAllocateVolume(), Resources
+  // are allocated with protocol installed and cached initialized
+  //
+  Status = FatAllocateVolume (ControllerHandle, DiskIo, DiskIo2, BlockIo);
+
+  //
+  // When the media changes on a device it will Reinstall the BlockIo interface.
+  // This will cause a call to our Stop(), and a subsequent reentrant call to our
+  // Start() successfully. We should leave the device open when this happen.
+  //
+  if (EFI_ERROR (Status)) {
+    Status = gBS->OpenProtocol (
+                    ControllerHandle,
+                    &gEfiSimpleFileSystemProtocolGuid,
+                    NULL,
+                    This->DriverBindingHandle,
+                    ControllerHandle,
+                    EFI_OPEN_PROTOCOL_TEST_PROTOCOL
+                    );
+    if (EFI_ERROR (Status)) {
+      gBS->CloseProtocol (
+             ControllerHandle,
+             &gEfiDiskIoProtocolGuid,
+             This->DriverBindingHandle,
+             ControllerHandle
+             );
+      gBS->CloseProtocol (
+             ControllerHandle,
+             &gEfiDiskIo2ProtocolGuid,
+             This->DriverBindingHandle,
+             ControllerHandle
+             );
+    }
+  }
+
+Exit:
+  //
+  // Unlock if locked by myself.
+  //
+  if (LockedByMe) {
+    FatReleaseLock ();
+  }
+  return Status;
+}
+
+/**
+
+  Stop this driver on ControllerHandle.
+
+  @param  This                  - Protocol instance pointer.
+  @param  ControllerHandle      - Handle of device to stop driver on.
+  @param  NumberOfChildren      - Not used.
+  @param  ChildHandleBuffer     - Not used.
+
+  @retval EFI_SUCCESS           - This driver is removed DeviceHandle.
+  @return other                 - This driver was not removed from this device.
+
+**/
+EFI_STATUS
+EFIAPI
+FatDriverBindingStop (
+  IN  EFI_DRIVER_BINDING_PROTOCOL   *This,
+  IN  EFI_HANDLE                    ControllerHandle,
+  IN  UINTN                         NumberOfChildren,
+  IN  EFI_HANDLE                    *ChildHandleBuffer
+  )
+{
+  EFI_STATUS                      Status;
+  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *FileSystem;
+  FAT_VOLUME                      *Volume;
+  EFI_DISK_IO2_PROTOCOL           *DiskIo2;
+
+  DiskIo2 = NULL;
+  //
+  // Get our context back
+  //
+  Status = gBS->OpenProtocol (
+                  ControllerHandle,
+                  &gEfiSimpleFileSystemProtocolGuid,
+                  (VOID **) &FileSystem,
+                  This->DriverBindingHandle,
+                  ControllerHandle,
+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
+                  );
+
+  if (!EFI_ERROR (Status)) {
+    Volume  = VOLUME_FROM_VOL_INTERFACE (FileSystem);
+    DiskIo2 = Volume->DiskIo2;
+    Status  = FatAbandonVolume (Volume);
+  }
+
+  if (!EFI_ERROR (Status)) {
+    if (DiskIo2 != NULL) {
+      Status = gBS->CloseProtocol (
+        ControllerHandle,
+        &gEfiDiskIo2ProtocolGuid,
+        This->DriverBindingHandle,
+        ControllerHandle
+        );
+      ASSERT_EFI_ERROR (Status);
+    }
+    Status = gBS->CloseProtocol (
+      ControllerHandle,
+      &gEfiDiskIoProtocolGuid,
+      This->DriverBindingHandle,
+      ControllerHandle
+      );
+    ASSERT_EFI_ERROR (Status);
+  }
+
+  return Status;
+}
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Fat.h b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Fat.h
new file mode 100644
index 00000000..a04a5a0f
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Fat.h
@@ -0,0 +1,2008 @@
+/** @file
+  Main header file for EFI FAT file system driver.
+
+Copyright (c) 2005 - 2013, Intel Corporation. All rights reserved.<BR>
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#ifndef _FAT_H_
+#define _FAT_H_
+
+#include <Uefi.h>
+
+#include <Guid/FileInfo.h>
+#include <Guid/FileSystemInfo.h>
+#include <Guid/FileSystemVolumeLabelInfo.h>
+#include <Protocol/BlockIo.h>
+#include <Protocol/DiskIo.h>
+#include <Protocol/DiskIo2.h>
+#include <Protocol/SimpleFileSystem.h>
+#include <Protocol/UnicodeCollation.h>
+
+#include <Library/PcdLib.h>
+#include <Library/DebugLib.h>
+#include <Library/UefiLib.h>
+#include <Library/BaseLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/UefiDriverEntryPoint.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/UefiRuntimeServicesTableLib.h>
+
+#include "FatFileSystem.h"
+
+//
+// The FAT signature
+//
+#define FAT_VOLUME_SIGNATURE         SIGNATURE_32 ('f', 'a', 't', 'v')
+#define FAT_IFILE_SIGNATURE          SIGNATURE_32 ('f', 'a', 't', 'i')
+#define FAT_ODIR_SIGNATURE           SIGNATURE_32 ('f', 'a', 't', 'd')
+#define FAT_DIRENT_SIGNATURE         SIGNATURE_32 ('f', 'a', 't', 'e')
+#define FAT_OFILE_SIGNATURE          SIGNATURE_32 ('f', 'a', 't', 'o')
+#define FAT_TASK_SIGNATURE           SIGNATURE_32 ('f', 'a', 't', 'T')
+#define FAT_SUBTASK_SIGNATURE        SIGNATURE_32 ('f', 'a', 't', 'S')
+
+#define ASSERT_VOLUME_LOCKED(a)      ASSERT_LOCKED (&FatFsLock)
+
+#define IFILE_FROM_FHAND(a)          CR (a, FAT_IFILE, Handle, FAT_IFILE_SIGNATURE)
+
+#define DIRENT_FROM_LINK(a)          CR (a, FAT_DIRENT, Link, FAT_DIRENT_SIGNATURE)
+
+#define VOLUME_FROM_ROOT_DIRENT(a)   CR (a, FAT_VOLUME, RootDirEnt, FAT_VOLUME_SIGNATURE)
+
+#define VOLUME_FROM_VOL_INTERFACE(a) CR (a, FAT_VOLUME, VolumeInterface, FAT_VOLUME_SIGNATURE);
+
+#define ODIR_FROM_DIRCACHELINK(a)    CR (a, FAT_ODIR, DirCacheLink, FAT_ODIR_SIGNATURE)
+
+#define OFILE_FROM_CHECKLINK(a)      CR (a, FAT_OFILE, CheckLink, FAT_OFILE_SIGNATURE)
+
+#define OFILE_FROM_CHILDLINK(a)      CR (a, FAT_OFILE, ChildLink, FAT_OFILE_SIGNATURE)
+
+//
+// Minimum sector size is 512B, Maximum sector size is 4096B
+// Max sectors per cluster is 128
+//
+#define MAX_BLOCK_ALIGNMENT               12
+#define MIN_BLOCK_ALIGNMENT               9
+#define MAX_SECTORS_PER_CLUSTER_ALIGNMENT 7
+
+//
+// Efi Time Definition
+//
+#define IS_LEAP_YEAR(a)                   (((a) % 4 == 0) && (((a) % 100 != 0) || ((a) % 400 == 0)))
+
+//
+// Minimum fat page size is 8K, maximum fat page alignment is 32K
+// Minimum data page size is 8K, maximum fat page alignment is 64K
+//
+#define FAT_FATCACHE_PAGE_MIN_ALIGNMENT   13
+#define FAT_FATCACHE_PAGE_MAX_ALIGNMENT   15
+#define FAT_DATACACHE_PAGE_MIN_ALIGNMENT  13
+#define FAT_DATACACHE_PAGE_MAX_ALIGNMENT  16
+#define FAT_DATACACHE_GROUP_COUNT         64
+#define FAT_FATCACHE_GROUP_MIN_COUNT      1
+#define FAT_FATCACHE_GROUP_MAX_COUNT      16
+
+//
+// Used in 8.3 generation algorithm
+//
+#define MAX_SPEC_RETRY          4
+#define SPEC_BASE_TAG_LEN       6
+#define HASH_BASE_TAG_LEN       2
+#define HASH_VALUE_TAG_LEN      (SPEC_BASE_TAG_LEN - HASH_BASE_TAG_LEN)
+
+//
+// Path name separator is back slash
+//
+#define PATH_NAME_SEPARATOR     L'\\'
+
+
+#define EFI_PATH_STRING_LENGTH  260
+#define EFI_FILE_STRING_LENGTH  255
+#define FAT_MAX_ALLOCATE_SIZE   0xA00000
+#define LC_ISO_639_2_ENTRY_SIZE 3
+#define MAX_LANG_CODE_SIZE      100
+
+#define FAT_MAX_DIR_CACHE_COUNT 8
+#define FAT_MAX_DIRENTRY_COUNT  0xFFFF
+typedef CHAR8                   LC_ISO_639_2;
+
+//
+// The fat types we support
+//
+typedef enum {
+  Fat12,
+  Fat16,
+  Fat32,
+  FatUndefined
+} FAT_VOLUME_TYPE;
+
+typedef enum {
+  CacheFat,
+  CacheData,
+  CacheMaxType
+} CACHE_DATA_TYPE;
+
+//
+// Used in FatDiskIo
+//
+typedef enum {
+  ReadDisk     = 0,  // raw disk read
+  WriteDisk    = 1,  // raw disk write
+  ReadFat      = 2,  // read fat cache
+  WriteFat     = 3,  // write fat cache
+  ReadData     = 6,  // read data cache
+  WriteData    = 7   // write data cache
+} IO_MODE;
+
+#define CACHE_ENABLED(a)  ((a) >= 2)
+#define RAW_ACCESS(a)     ((IO_MODE)((a) & 0x1))
+#define CACHE_TYPE(a)     ((CACHE_DATA_TYPE)((a) >> 2))
+
+//
+// Disk cache tag
+//
+typedef struct {
+  UINTN   PageNo;
+  UINTN   RealSize;
+  BOOLEAN Dirty;
+} CACHE_TAG;
+
+typedef struct {
+  UINT64    BaseAddress;
+  UINT64    LimitAddress;
+  UINT8     *CacheBase;
+  BOOLEAN   Dirty;
+  UINT8     PageAlignment;
+  UINTN     GroupMask;
+  CACHE_TAG CacheTag[FAT_DATACACHE_GROUP_COUNT];
+} DISK_CACHE;
+
+//
+// Hash table size
+//
+#define HASH_TABLE_SIZE  0x400
+#define HASH_TABLE_MASK  (HASH_TABLE_SIZE - 1)
+
+//
+// The directory entry for opened directory
+//
+
+typedef struct _FAT_DIRENT FAT_DIRENT;
+typedef struct _FAT_ODIR FAT_ODIR;
+typedef struct _FAT_OFILE FAT_OFILE;
+typedef struct _FAT_VOLUME FAT_VOLUME;
+
+struct _FAT_DIRENT {
+  UINTN               Signature;
+  UINT16              EntryPos;               // The position of this directory entry in the parent directory file
+  UINT8               EntryCount;             // The count of the directory entry in the parent directory file
+  BOOLEAN             Invalid;                // Indicate whether this directory entry is valid
+  CHAR16              *FileString;            // The unicode long file name for this directory entry
+  FAT_OFILE           *OFile;                 // The OFile of the corresponding directory entry
+  FAT_DIRENT          *ShortNameForwardLink;  // Hash successor link for short filename
+  FAT_DIRENT          *LongNameForwardLink;   // Hash successor link for long filename
+  LIST_ENTRY          Link;                   // Connection of every directory entry
+  FAT_DIRECTORY_ENTRY Entry;                  // The physical directory entry stored in disk
+};
+
+struct _FAT_ODIR {
+  UINTN               Signature;
+  UINT32              CurrentEndPos;          // Current end position of the directory
+  UINT32              CurrentPos;             // Current position of the directory
+  LIST_ENTRY          *CurrentCursor;         // Current directory entry pointer
+  LIST_ENTRY          ChildList;              // List of all directory entries
+  BOOLEAN             EndOfDir;               // Indicate whether we have reached the end of the directory
+  LIST_ENTRY          DirCacheLink;           // Linked in Volume->DirCacheList when discarded
+  UINTN               DirCacheTag;            // The identification of the directory when in directory cache
+  FAT_DIRENT          *LongNameHashTable[HASH_TABLE_SIZE];
+  FAT_DIRENT          *ShortNameHashTable[HASH_TABLE_SIZE];
+};
+
+typedef struct {
+  UINTN               Signature;
+  EFI_FILE_PROTOCOL   Handle;
+  UINT64              Position;
+  BOOLEAN             ReadOnly;
+  FAT_OFILE          *OFile;
+  LIST_ENTRY          Tasks;                  // List of all FAT_TASKs
+  LIST_ENTRY          Link;                   // Link to other IFiles
+} FAT_IFILE;
+
+typedef struct {
+  UINTN               Signature;
+  EFI_FILE_IO_TOKEN   *FileIoToken;
+  FAT_IFILE           *IFile;
+  LIST_ENTRY          Subtasks;               // List of all FAT_SUBTASKs
+  LIST_ENTRY          Link;                   // Link to other FAT_TASKs
+} FAT_TASK;
+
+typedef struct {
+  UINTN               Signature;
+  EFI_DISK_IO2_TOKEN  DiskIo2Token;
+  FAT_TASK            *Task;
+  BOOLEAN             Write;
+  UINT64              Offset;
+  VOID                *Buffer;
+  UINTN               BufferSize;
+  LIST_ENTRY          Link;
+} FAT_SUBTASK;
+
+//
+// FAT_OFILE - Each opened file
+//
+struct _FAT_OFILE {
+  UINTN               Signature;
+  FAT_VOLUME          *Volume;
+  //
+  // A permanent error code to return to all accesses to
+  // this opened file
+  //
+  EFI_STATUS          Error;
+  //
+  // A list of the IFILE instances for this OFile
+  //
+  LIST_ENTRY          Opens;
+
+  //
+  // The dynamic information
+  //
+  UINTN               FileSize;
+  UINTN               FileCluster;
+  UINTN               FileCurrentCluster;
+  UINTN               FileLastCluster;
+
+  //
+  // Dirty is set if there have been any updates to the
+  // file
+  // Archive is set if the archive attribute in the file's
+  // directory entry needs to be set when performing flush
+  // PreserveLastMod is set if the last modification of the
+  // file is specified by SetInfo API
+  //
+  BOOLEAN             Dirty;
+  BOOLEAN             IsFixedRootDir;
+  BOOLEAN             PreserveLastModification;
+  BOOLEAN             Archive;
+  //
+  // Set by an OFile SetPosition
+  //
+  UINTN               Position; // within file
+  UINT64              PosDisk;  // on the disk
+  UINTN               PosRem;   // remaining in this disk run
+  //
+  // The opened parent, full path length and currently opened child files
+  //
+  FAT_OFILE           *Parent;
+  UINTN               FullPathLen;
+  LIST_ENTRY          ChildHead;
+  LIST_ENTRY          ChildLink;
+
+  //
+  // The opened directory structure for a directory; if this
+  // OFile represents a file, then ODir = NULL
+  //
+  FAT_ODIR            *ODir;
+  //
+  // The directory entry for the Ofile
+  //
+  FAT_DIRENT          *DirEnt;
+
+  //
+  // Link in Volume's reference list
+  //
+  LIST_ENTRY          CheckLink;
+};
+
+struct _FAT_VOLUME {
+  UINTN                           Signature;
+
+  EFI_HANDLE                      Handle;
+  BOOLEAN                         Valid;
+  BOOLEAN                         DiskError;
+
+  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL VolumeInterface;
+
+  //
+  // If opened, the parent handle and BlockIo interface
+  //
+  EFI_BLOCK_IO_PROTOCOL           *BlockIo;
+  EFI_DISK_IO_PROTOCOL            *DiskIo;
+  EFI_DISK_IO2_PROTOCOL           *DiskIo2;
+  UINT32                          MediaId;
+  BOOLEAN                         ReadOnly;
+
+  //
+  // Computed values from fat bpb info
+  //
+  UINT64                          VolumeSize;
+  UINT64                          FatPos;           // Disk pos of fat tables
+  UINT64                          RootPos;          // Disk pos of root directory
+  UINT64                          FirstClusterPos;  // Disk pos of first cluster
+  UINTN                           FatSize;          // Number of bytes in each fat
+  UINTN                           MaxCluster;       // Max cluster number
+  UINTN                           ClusterSize;      // Cluster size of fat partition
+  UINT8                           ClusterAlignment; // Equal to log_2 (clustersize);
+  FAT_VOLUME_TYPE                 FatType;
+
+  //
+  // Current part of fat table that's present
+  //
+  UINT64                          FatEntryPos;    // Location of buffer
+  UINTN                           FatEntrySize;   // Size of buffer
+  UINT32                          FatEntryBuffer; // The buffer
+  FAT_INFO_SECTOR                 FatInfoSector;  // Free cluster info
+  UINTN                           FreeInfoPos;    // Pos with the free cluster info
+  BOOLEAN                         FreeInfoValid;  // If free cluster info is valid
+  //
+  // Unpacked Fat BPB info
+  //
+  UINTN                           NumFats;
+  UINTN                           RootEntries;    // < FAT32, root dir is fixed size
+  UINTN                           RootCluster;    // >= FAT32, root cluster chain head
+  //
+  // info for marking the volume dirty or not
+  //
+  BOOLEAN                         FatDirty;       // If fat-entries have been updated
+  UINT32                          DirtyValue;
+  UINT32                          NotDirtyValue;
+
+  //
+  // The root directory entry and opened root file
+  //
+  FAT_DIRENT                      RootDirEnt;
+  //
+  // File Name of root OFile, it is empty string
+  //
+  CHAR16                          RootFileString[1];
+  FAT_OFILE                       *Root;
+
+  //
+  // New OFiles are added to this list so they
+  // can be cleaned up if they aren't referenced.
+  //
+  LIST_ENTRY                      CheckRef;
+
+  //
+  // Directory cache List
+  //
+  LIST_ENTRY                      DirCacheList;
+  UINTN                           DirCacheCount;
+
+  //
+  // Disk Cache for this volume
+  //
+  VOID                            *CacheBuffer;
+  DISK_CACHE                      DiskCache[CacheMaxType];
+};
+
+//
+// Function Prototypes
+//
+
+/**
+
+  Implements Open() of Simple File System Protocol.
+
+  @param  FHand                 - File handle of the file serves as a starting reference point.
+  @param  NewHandle             - Handle of the file that is newly opened.
+  @param  FileName              - File name relative to FHand.
+  @param  OpenMode              - Open mode.
+  @param  Attributes            - Attributes to set if the file is created.
+
+
+  @retval EFI_INVALID_PARAMETER - The FileName is NULL or the file string is empty.
+                          The OpenMode is not supported.
+                          The Attributes is not the valid attributes.
+  @retval EFI_OUT_OF_RESOURCES  - Can not allocate the memory for file string.
+  @retval EFI_SUCCESS           - Open the file successfully.
+  @return Others                - The status of open file.
+
+**/
+EFI_STATUS
+EFIAPI
+FatOpen (
+  IN  EFI_FILE_PROTOCOL *FHand,
+  OUT EFI_FILE_PROTOCOL **NewHandle,
+  IN  CHAR16            *FileName,
+  IN  UINT64            OpenMode,
+  IN  UINT64            Attributes
+  )
+;
+
+/**
+
+  Implements OpenEx() of Simple File System Protocol.
+
+  @param  FHand                 - File handle of the file serves as a starting reference point.
+  @param  NewHandle             - Handle of the file that is newly opened.
+  @param  FileName              - File name relative to FHand.
+  @param  OpenMode              - Open mode.
+  @param  Attributes            - Attributes to set if the file is created.
+  @param  Token                 - A pointer to the token associated with the transaction.
+
+  @retval EFI_INVALID_PARAMETER - The FileName is NULL or the file string is empty.
+                          The OpenMode is not supported.
+                          The Attributes is not the valid attributes.
+  @retval EFI_OUT_OF_RESOURCES  - Can not allocate the memory for file string.
+  @retval EFI_SUCCESS           - Open the file successfully.
+  @return Others                - The status of open file.
+
+**/
+EFI_STATUS
+EFIAPI
+FatOpenEx (
+  IN  EFI_FILE_PROTOCOL       *FHand,
+  OUT EFI_FILE_PROTOCOL       **NewHandle,
+  IN  CHAR16                  *FileName,
+  IN  UINT64                  OpenMode,
+  IN  UINT64                  Attributes,
+  IN OUT EFI_FILE_IO_TOKEN    *Token
+  )
+;
+
+/**
+
+  Get the file's position of the file
+
+  @param  FHand                 - The handle of file.
+  @param  Position              - The file's position of the file.
+
+  @retval EFI_SUCCESS           - Get the info successfully.
+  @retval EFI_DEVICE_ERROR      - Can not find the OFile for the file.
+  @retval EFI_UNSUPPORTED       - The open file is not a file.
+
+**/
+EFI_STATUS
+EFIAPI
+FatGetPosition (
+  IN  EFI_FILE_PROTOCOL *FHand,
+  OUT UINT64            *Position
+  )
+;
+
+/**
+
+  Get the some types info of the file into Buffer
+
+  @param  FHand                 - The handle of file.
+  @param  Type                  - The type of the info.
+  @param  BufferSize            - Size of Buffer.
+  @param  Buffer                - Buffer containing volume info.
+
+  @retval EFI_SUCCESS           - Get the info successfully.
+  @retval EFI_DEVICE_ERROR      - Can not find the OFile for the file.
+
+**/
+EFI_STATUS
+EFIAPI
+FatGetInfo (
+  IN     EFI_FILE_PROTOCOL      *FHand,
+  IN     EFI_GUID               *Type,
+  IN OUT UINTN                  *BufferSize,
+     OUT VOID                   *Buffer
+  )
+;
+
+/**
+
+  Set the some types info of the file into Buffer.
+
+  @param  FHand                 - The handle of file.
+  @param  Type                  - The type of the info.
+  @param  BufferSize            - Size of Buffer.
+  @param  Buffer                - Buffer containing volume info.
+
+  @retval EFI_SUCCESS           - Set the info successfully.
+  @retval EFI_DEVICE_ERROR      - Can not find the OFile for the file.
+
+**/
+EFI_STATUS
+EFIAPI
+FatSetInfo (
+  IN EFI_FILE_PROTOCOL  *FHand,
+  IN EFI_GUID           *Type,
+  IN UINTN              BufferSize,
+  IN VOID               *Buffer
+  )
+;
+
+/**
+
+  Flushes all data associated with the file handle.
+
+  @param  FHand                 - Handle to file to flush
+
+  @retval EFI_SUCCESS           - Flushed the file successfully
+  @retval EFI_WRITE_PROTECTED   - The volume is read only
+  @retval EFI_ACCESS_DENIED     - The volume is not read only
+                          but the file is read only
+  @return Others                - Flushing of the file is failed
+
+**/
+EFI_STATUS
+EFIAPI
+FatFlush (
+  IN EFI_FILE_PROTOCOL  *FHand
+  )
+;
+
+/**
+
+  Flushes all data associated with the file handle.
+
+  @param  FHand                 - Handle to file to flush.
+  @param  Token                 - A pointer to the token associated with the transaction.
+
+  @retval EFI_SUCCESS           - Flushed the file successfully.
+  @retval EFI_WRITE_PROTECTED   - The volume is read only.
+  @retval EFI_ACCESS_DENIED     - The file is read only.
+  @return Others                - Flushing of the file failed.
+
+**/
+EFI_STATUS
+EFIAPI
+FatFlushEx (
+  IN EFI_FILE_PROTOCOL  *FHand,
+  IN EFI_FILE_IO_TOKEN  *Token
+  )
+;
+
+/**
+
+  Flushes & Closes the file handle.
+
+  @param  FHand                 - Handle to the file to delete.
+
+  @retval EFI_SUCCESS           - Closed the file successfully.
+
+**/
+EFI_STATUS
+EFIAPI
+FatClose (
+  IN EFI_FILE_PROTOCOL  *FHand
+  )
+;
+
+/**
+
+  Deletes the file & Closes the file handle.
+
+  @param  FHand                    - Handle to the file to delete.
+
+  @retval EFI_SUCCESS              - Delete the file successfully.
+  @retval EFI_WARN_DELETE_FAILURE  - Fail to delete the file.
+
+**/
+EFI_STATUS
+EFIAPI
+FatDelete (
+  IN EFI_FILE_PROTOCOL  *FHand
+  )
+;
+
+/**
+
+  Set the file's position of the file.
+
+  @param  FHand                 - The handle of file
+  @param  Position              - The file's position of the file
+
+  @retval EFI_SUCCESS           - Set the info successfully
+  @retval EFI_DEVICE_ERROR      - Can not find the OFile for the file
+  @retval EFI_UNSUPPORTED       - Set a directory with a not-zero position
+
+**/
+EFI_STATUS
+EFIAPI
+FatSetPosition (
+  IN EFI_FILE_PROTOCOL  *FHand,
+  IN UINT64             Position
+  )
+;
+
+/**
+
+  Get the file info.
+
+  @param FHand                 - The handle of the file.
+  @param BufferSize            - Size of Buffer.
+  @param Buffer                - Buffer containing read data.
+
+  @retval EFI_SUCCESS           - Get the file info successfully.
+  @retval EFI_DEVICE_ERROR      - Can not find the OFile for the file.
+  @retval EFI_VOLUME_CORRUPTED  - The file type of open file is error.
+  @return other                 - An error occurred when operation the disk.
+
+**/
+EFI_STATUS
+EFIAPI
+FatRead (
+  IN     EFI_FILE_PROTOCOL    *FHand,
+  IN OUT UINTN                *BufferSize,
+     OUT VOID                 *Buffer
+  )
+;
+
+/**
+
+  Get the file info.
+
+  @param FHand                 - The handle of the file.
+  @param Token                 - A pointer to the token associated with the transaction.
+
+  @retval EFI_SUCCESS           - Get the file info successfully.
+  @retval EFI_DEVICE_ERROR      - Can not find the OFile for the file.
+  @retval EFI_VOLUME_CORRUPTED  - The file type of open file is error.
+  @return other                 - An error occurred when operation the disk.
+
+**/
+EFI_STATUS
+EFIAPI
+FatReadEx (
+  IN     EFI_FILE_PROTOCOL  *FHand,
+  IN OUT EFI_FILE_IO_TOKEN  *Token
+  )
+;
+
+/**
+
+  Set the file info.
+
+  @param  FHand                 - The handle of the file.
+  @param  BufferSize            - Size of Buffer.
+  @param Buffer                - Buffer containing write data.
+
+  @retval EFI_SUCCESS           - Set the file info successfully.
+  @retval EFI_WRITE_PROTECTED   - The disk is write protected.
+  @retval EFI_ACCESS_DENIED     - The file is read-only.
+  @retval EFI_DEVICE_ERROR      - The OFile is not valid.
+  @retval EFI_UNSUPPORTED       - The open file is not a file.
+                        - The writing file size is larger than 4GB.
+  @return other                 - An error occurred when operation the disk.
+
+**/
+EFI_STATUS
+EFIAPI
+FatWrite (
+  IN     EFI_FILE_PROTOCOL      *FHand,
+  IN OUT UINTN                  *BufferSize,
+  IN     VOID                   *Buffer
+  )
+;
+
+/**
+
+  Get the file info.
+
+  @param  FHand                 - The handle of the file.
+  @param  Token                 - A pointer to the token associated with the transaction.
+
+  @retval EFI_SUCCESS           - Get the file info successfully.
+  @retval EFI_DEVICE_ERROR      - Can not find the OFile for the file.
+  @retval EFI_VOLUME_CORRUPTED  - The file type of open file is error.
+  @return other                 - An error occurred when operation the disk.
+
+**/
+EFI_STATUS
+EFIAPI
+FatWriteEx (
+  IN     EFI_FILE_PROTOCOL  *FHand,
+  IN OUT EFI_FILE_IO_TOKEN  *Token
+  )
+;
+
+//
+// DiskCache.c
+//
+/**
+
+  Initialize the disk cache according to Volume's FatType.
+
+  @param  Volume                - FAT file system volume.
+
+  @retval EFI_SUCCESS           - The disk cache is successfully initialized.
+  @retval EFI_OUT_OF_RESOURCES  - Not enough memory to allocate disk cache.
+
+**/
+EFI_STATUS
+FatInitializeDiskCache (
+  IN FAT_VOLUME              *Volume
+  );
+
+/**
+
+  Read BufferSize bytes from the position of Offset into Buffer,
+  or write BufferSize bytes from Buffer into the position of Offset.
+
+  Base on the parameter of CACHE_DATA_TYPE, the data access will be divided into
+  the access of FAT cache (CACHE_FAT) and the access of Data cache (CACHE_DATA):
+
+  1. Access of FAT cache (CACHE_FAT): Access the data in the FAT cache, if there is cache
+     page hit, just return the cache page; else update the related cache page and return
+     the right cache page.
+  2. Access of Data cache (CACHE_DATA):
+     The access data will be divided into UnderRun data, Aligned data and OverRun data;
+     The UnderRun data and OverRun data will be accessed by the Data cache,
+     but the Aligned data will be accessed with disk directly.
+
+  @param  Volume                - FAT file system volume.
+  @param  CacheDataType         - The type of cache: CACHE_DATA or CACHE_FAT.
+  @param  IoMode                - Indicate the type of disk access.
+  @param  Offset                - The starting byte offset to read from.
+  @param  BufferSize            - Size of Buffer.
+  @param  Buffer                - Buffer containing cache data.
+  @param  Task                    point to task instance.
+
+  @retval EFI_SUCCESS           - The data was accessed correctly.
+  @retval EFI_MEDIA_CHANGED     - The MediaId does not match the current device.
+  @return Others                - An error occurred when accessing cache.
+
+**/
+EFI_STATUS
+FatAccessCache (
+  IN     FAT_VOLUME          *Volume,
+  IN     CACHE_DATA_TYPE     CacheDataType,
+  IN     IO_MODE             IoMode,
+  IN     UINT64              Offset,
+  IN     UINTN               BufferSize,
+  IN OUT UINT8               *Buffer,
+  IN     FAT_TASK            *Task
+  );
+
+/**
+
+  Flush all the dirty cache back, include the FAT cache and the Data cache.
+
+  @param  Volume                - FAT file system volume.
+  @param  Task                    point to task instance.
+
+  @retval EFI_SUCCESS           - Flush all the dirty cache back successfully
+  @return other                 - An error occurred when writing the data into the disk
+
+**/
+EFI_STATUS
+FatVolumeFlushCache (
+  IN FAT_VOLUME              *Volume,
+  IN FAT_TASK                *Task
+  );
+
+//
+// Flush.c
+//
+/**
+
+  Flush the data associated with an open file.
+  In this implementation, only last Mod/Access time is updated.
+
+  @param  OFile                 - The open file.
+
+  @retval EFI_SUCCESS           - The OFile is flushed successfully.
+  @return Others                - An error occurred when flushing this OFile.
+
+**/
+EFI_STATUS
+FatOFileFlush (
+  IN FAT_OFILE          *OFile
+  );
+
+/**
+
+  Check the references of the OFile.
+  If the OFile (that is checked) is no longer
+  referenced, then it is freed.
+
+  @param  OFile                 - The OFile to be checked.
+
+  @retval TRUE                  - The OFile is not referenced and freed.
+  @retval FALSE                 - The OFile is kept.
+
+**/
+BOOLEAN
+FatCheckOFileRef (
+  IN FAT_OFILE          *OFile
+  );
+
+/**
+
+  Set the OFile and its child OFile with the error Status
+
+  @param  OFile                 - The OFile whose permanent error code is to be set.
+  @param  Status                - Error code to be set.
+
+**/
+VOID
+FatSetVolumeError (
+  IN FAT_OFILE          *OFile,
+  IN EFI_STATUS         Status
+  );
+
+/**
+
+  Close the open file instance.
+
+  @param  IFile                 - Open file instance.
+
+  @retval EFI_SUCCESS           - Closed the file successfully.
+
+**/
+EFI_STATUS
+FatIFileClose (
+  FAT_IFILE             *IFile
+  );
+
+/**
+
+  Set error status for a specific OFile, reference checking the volume.
+  If volume is already marked as invalid, and all resources are freed
+  after reference checking, the file system protocol is uninstalled and
+  the volume structure is freed.
+
+  @param  Volume                - the Volume that is to be reference checked and unlocked.
+  @param  OFile                 - the OFile whose permanent error code is to be set.
+  @param  EfiStatus             - error code to be set.
+  @param  Task                    point to task instance.
+
+  @retval EFI_SUCCESS           - Clean up the volume successfully.
+  @return Others                - Cleaning up of the volume is failed.
+
+**/
+EFI_STATUS
+FatCleanupVolume (
+  IN FAT_VOLUME         *Volume,
+  IN FAT_OFILE          *OFile,
+  IN EFI_STATUS         EfiStatus,
+  IN FAT_TASK           *Task
+  );
+
+//
+// FileSpace.c
+//
+/**
+
+  Shrink the end of the open file base on the file size.
+
+  @param  OFile                 - The open file.
+
+  @retval EFI_SUCCESS           - Shrinked successfully.
+  @retval EFI_VOLUME_CORRUPTED  - There are errors in the file's clusters.
+
+**/
+EFI_STATUS
+FatShrinkEof (
+  IN FAT_OFILE          *OFile
+  );
+
+/**
+
+  Grow the end of the open file base on the NewSizeInBytes.
+
+  @param  OFile                 - The open file.
+  @param  NewSizeInBytes        - The new size in bytes of the open file.
+
+  @retval EFI_SUCCESS           - The file is grown successfully.
+  @retval EFI_UNSUPPORTED       - The file size is larger than 4GB.
+  @retval EFI_VOLUME_CORRUPTED  - There are errors in the files' clusters.
+  @retval EFI_VOLUME_FULL       - The volume is full and can not grow the file.
+
+**/
+EFI_STATUS
+FatGrowEof (
+  IN FAT_OFILE          *OFile,
+  IN UINT64             NewSizeInBytes
+  );
+
+/**
+
+  Get the size of directory of the open file.
+
+  @param  Volume                - The File System Volume.
+  @param  Cluster               - The Starting cluster.
+
+  @return The physical size of the file starting at the input cluster, if there is error in the
+  cluster chain, the return value is 0.
+
+**/
+UINTN
+FatPhysicalDirSize (
+  IN FAT_VOLUME         *Volume,
+  IN UINTN              Cluster
+  );
+
+/**
+
+  Get the physical size of a file on the disk.
+
+  @param  Volume                - The file system volume.
+  @param  RealSize              - The real size of a file.
+
+  @return The physical size of a file on the disk.
+
+**/
+UINT64
+FatPhysicalFileSize (
+  IN FAT_VOLUME         *Volume,
+  IN UINTN              RealSize
+  );
+
+/**
+
+  Seek OFile to requested position, and calculate the number of
+  consecutive clusters from the position in the file
+
+  @param  OFile                 - The open file.
+  @param  Position              - The file's position which will be accessed.
+  @param  PosLimit              - The maximum length current reading/writing may access
+
+  @retval EFI_SUCCESS           - Set the info successfully.
+  @retval EFI_VOLUME_CORRUPTED  - Cluster chain corrupt.
+
+**/
+EFI_STATUS
+FatOFilePosition (
+  IN FAT_OFILE            *OFile,
+  IN UINTN                Position,
+  IN UINTN                PosLimit
+  );
+
+/**
+
+  Update the free cluster info of FatInfoSector of the volume.
+
+  @param  Volume                - FAT file system volume.
+
+**/
+VOID
+FatComputeFreeInfo (
+  IN FAT_VOLUME         *Volume
+  );
+
+//
+// Init.c
+//
+/**
+
+  Allocates volume structure, detects FAT file system, installs protocol,
+  and initialize cache.
+
+  @param  Handle                - The handle of parent device.
+  @param  DiskIo                - The DiskIo of parent device.
+  @param  DiskIo2               - The DiskIo2 of parent device.
+  @param  BlockIo               - The BlockIo of parent device.
+
+  @retval EFI_SUCCESS           - Allocate a new volume successfully.
+  @retval EFI_OUT_OF_RESOURCES  - Can not allocate the memory.
+  @return Others                - Allocating a new volume failed.
+
+**/
+EFI_STATUS
+FatAllocateVolume (
+  IN  EFI_HANDLE                     Handle,
+  IN  EFI_DISK_IO_PROTOCOL           *DiskIo,
+  IN  EFI_DISK_IO2_PROTOCOL          *DiskIo2,
+  IN  EFI_BLOCK_IO_PROTOCOL          *BlockIo
+  );
+
+/**
+
+  Detects FAT file system on Disk and set relevant fields of Volume.
+
+  @param Volume                - The volume structure.
+
+  @retval EFI_SUCCESS           - The Fat File System is detected successfully
+  @retval EFI_UNSUPPORTED       - The volume is not FAT file system.
+  @retval EFI_VOLUME_CORRUPTED  - The volume is corrupted.
+
+**/
+EFI_STATUS
+FatOpenDevice (
+  IN OUT FAT_VOLUME     *Volume
+  );
+
+/**
+
+  Called by FatDriverBindingStop(), Abandon the volume.
+
+  @param  Volume                - The volume to be abandoned.
+
+  @retval EFI_SUCCESS           - Abandoned the volume successfully.
+  @return Others                - Can not uninstall the protocol interfaces.
+
+**/
+EFI_STATUS
+FatAbandonVolume (
+  IN FAT_VOLUME         *Volume
+  );
+
+//
+// Misc.c
+//
+/**
+
+  Create the task
+
+  @param  IFile                 - The instance of the open file.
+  @param  Token                 - A pointer to the token associated with the transaction.
+
+  @return FAT_TASK *            - Return the task instance.
+
+**/
+FAT_TASK *
+FatCreateTask (
+  FAT_IFILE           *IFile,
+  EFI_FILE_IO_TOKEN   *Token
+  );
+
+/**
+
+  Destroy the task.
+
+  @param  Task                  - The task to be destroyed.
+
+**/
+VOID
+FatDestroyTask (
+  FAT_TASK            *Task
+  );
+
+/**
+
+  Wait all non-blocking requests complete.
+
+  @param  IFile                 - The instance of the open file.
+
+**/
+VOID
+FatWaitNonblockingTask (
+  FAT_IFILE           *IFile
+  );
+
+/**
+
+  Remove the subtask from subtask list.
+
+  @param  Subtask               - The subtask to be removed.
+
+  @return LIST_ENTRY *          - The next node in the list.
+
+**/
+LIST_ENTRY *
+FatDestroySubtask (
+  FAT_SUBTASK         *Subtask
+  );
+
+/**
+
+  Execute the task.
+
+  @param  IFile                 - The instance of the open file.
+  @param  Task                  - The task to be executed.
+
+  @retval EFI_SUCCESS           - The task was executed successfully.
+  @return other                 - An error occurred when executing the task.
+
+**/
+EFI_STATUS
+FatQueueTask (
+  IN FAT_IFILE        *IFile,
+  IN FAT_TASK         *Task
+  );
+
+/**
+
+  Set the volume as dirty or not.
+
+  @param  Volume                - FAT file system volume.
+  @param  IoMode                - The access mode.
+  @param  DirtyValue            - Set the volume as dirty or not.
+
+  @retval EFI_SUCCESS           - Set the new FAT entry value successfully.
+  @return other                 - An error occurred when operation the FAT entries.
+
+**/
+EFI_STATUS
+FatAccessVolumeDirty (
+  IN FAT_VOLUME         *Volume,
+  IN IO_MODE            IoMode,
+  IN VOID               *DirtyValue
+  );
+
+/**
+
+  General disk access function.
+
+  @param  Volume                - FAT file system volume.
+  @param  IoMode                - The access mode (disk read/write or cache access).
+  @param  Offset                - The starting byte offset to read from.
+  @param  BufferSize            - Size of Buffer.
+  @param  Buffer                - Buffer containing read data.
+  @param  Task                    point to task instance.
+
+  @retval EFI_SUCCESS           - The operation is performed successfully.
+  @retval EFI_VOLUME_CORRUPTED  - The access is
+  @return Others                - The status of read/write the disk
+
+**/
+EFI_STATUS
+FatDiskIo (
+  IN FAT_VOLUME         *Volume,
+  IN IO_MODE            IoMode,
+  IN UINT64             Offset,
+  IN UINTN              BufferSize,
+  IN OUT VOID           *Buffer,
+  IN FAT_TASK           *Task
+  );
+
+/**
+
+  Lock the volume.
+
+**/
+VOID
+FatAcquireLock (
+  VOID
+  );
+
+/**
+
+  Unlock the volume.
+
+**/
+VOID
+FatReleaseLock (
+  VOID
+  );
+
+/**
+
+  Lock the volume.
+  If the lock is already in the acquired state, then EFI_ACCESS_DENIED is returned.
+  Otherwise, EFI_SUCCESS is returned.
+
+  @retval EFI_SUCCESS           - The volume is locked.
+  @retval EFI_ACCESS_DENIED     - The volume could not be locked because it is already locked.
+
+**/
+EFI_STATUS
+FatAcquireLockOrFail (
+  VOID
+  );
+
+/**
+
+  Free directory entry.
+
+  @param  DirEnt                - The directory entry to be freed.
+
+**/
+VOID
+FatFreeDirEnt (
+  IN FAT_DIRENT         *DirEnt
+  );
+
+/**
+
+  Free volume structure (including the contents of directory cache and disk cache).
+
+  @param  Volume                - The volume structure to be freed.
+
+**/
+VOID
+FatFreeVolume (
+  IN FAT_VOLUME         *Volume
+  );
+
+/**
+
+  Translate EFI time to FAT time.
+
+  @param  ETime                 - The time of EFI_TIME.
+  @param  FTime                 - The time of FAT_DATE_TIME.
+
+**/
+VOID
+FatEfiTimeToFatTime (
+  IN EFI_TIME           *ETime,
+  OUT FAT_DATE_TIME     *FTime
+  );
+
+/**
+
+  Translate Fat time to EFI time.
+
+  @param  FTime                 - The time of FAT_DATE_TIME.
+  @param  ETime                 - The time of EFI_TIME..
+
+**/
+VOID
+FatFatTimeToEfiTime (
+  IN FAT_DATE_TIME      *FTime,
+  OUT EFI_TIME          *ETime
+  );
+
+/**
+
+  Get Current FAT time.
+
+  @param  FatTime               - Current FAT time.
+
+**/
+VOID
+FatGetCurrentFatTime (
+  OUT FAT_DATE_TIME     *FatTime
+  );
+
+/**
+
+  Check whether a time is valid.
+
+  @param  Time                  - The time of EFI_TIME.
+
+  @retval TRUE                  - The time is valid.
+  @retval FALSE                 - The time is not valid.
+
+**/
+BOOLEAN
+FatIsValidTime (
+  IN EFI_TIME           *Time
+  );
+
+//
+// UnicodeCollation.c
+//
+/**
+  Initialize Unicode Collation support.
+
+  It tries to locate Unicode Collation 2 protocol and matches it with current
+  platform language code. If for any reason the first attempt fails, it then tries to
+  use Unicode Collation Protocol.
+
+  @param  AgentHandle          The handle used to open Unicode Collation (2) protocol.
+
+  @retval EFI_SUCCESS          The Unicode Collation (2) protocol has been successfully located.
+  @retval Others               The Unicode Collation (2) protocol has not been located.
+
+**/
+EFI_STATUS
+InitializeUnicodeCollationSupport (
+  IN EFI_HANDLE    AgentHandle
+  );
+
+/**
+  Convert FAT string to unicode string.
+
+  @param  FatSize               The size of FAT string.
+  @param  Fat                   The FAT string.
+  @param  String                The unicode string.
+
+  @return None.
+
+**/
+VOID
+FatFatToStr (
+  IN UINTN              FatSize,
+  IN CHAR8              *Fat,
+  OUT CHAR16            *String
+  );
+
+/**
+  Convert unicode string to Fat string.
+
+  @param  String                The unicode string.
+  @param  FatSize               The size of the FAT string.
+  @param  Fat                   The FAT string.
+
+  @retval TRUE                  Convert successfully.
+  @retval FALSE                 Convert error.
+
+**/
+BOOLEAN
+FatStrToFat (
+  IN  CHAR16            *String,
+  IN  UINTN             FatSize,
+  OUT CHAR8             *Fat
+  );
+
+/**
+  Lowercase a string
+
+  @param  Str                   The string which will be lower-cased.
+
+**/
+VOID
+FatStrLwr (
+  IN CHAR16             *Str
+  );
+
+/**
+  Uppercase a string.
+
+  @param  Str                   The string which will be upper-cased.
+
+**/
+VOID
+FatStrUpr (
+  IN CHAR16             *Str
+  );
+
+/**
+  Performs a case-insensitive comparison of two Null-terminated Unicode strings.
+
+  @param  Str1                   A pointer to a Null-terminated Unicode string.
+  @param  Str2                   A pointer to a Null-terminated Unicode string.
+
+  @retval 0                    S1 is equivalent to S2.
+  @retval >0                   S1 is lexically greater than S2.
+  @retval <0                   S1 is lexically less than S2.
+**/
+INTN
+FatStriCmp (
+  IN CHAR16             *Str1,
+  IN CHAR16             *Str2
+  );
+
+//
+// Open.c
+//
+
+/**
+
+  Open a file for a file name relative to an existing OFile.
+  The IFile of the newly opened file is passed out.
+
+  @param  OFile                 - The file that serves as a starting reference point.
+  @param  NewIFile              - The newly generated IFile instance.
+  @param  FileName              - The file name relative to the OFile.
+  @param  OpenMode              - Open mode.
+  @param  Attributes            - Attributes to set if the file is created.
+
+
+  @retval EFI_SUCCESS           - Open the file successfully.
+  @retval EFI_INVALID_PARAMETER - The open mode is conflict with the attributes
+                          or the file name is not valid.
+  @retval EFI_NOT_FOUND         - Conflicts between dir intention and attribute.
+  @retval EFI_WRITE_PROTECTED   - Can't open for write if the volume is read only.
+  @retval EFI_ACCESS_DENIED     - If the file's attribute is read only, and the
+                          open is for read-write fail it.
+  @retval EFI_OUT_OF_RESOURCES  - Can not allocate the memory.
+
+**/
+EFI_STATUS
+FatOFileOpen (
+  IN FAT_OFILE          *OFile,
+  OUT FAT_IFILE         **NewIFile,
+  IN CHAR16             *FileName,
+  IN UINT64             OpenMode,
+  IN UINT8              Attributes
+  );
+
+/**
+
+  Create an Open instance for the existing OFile.
+  The IFile of the newly opened file is passed out.
+
+  @param  OFile                 - The file that serves as a starting reference point.
+  @param  PtrIFile              - The newly generated IFile instance.
+
+  @retval EFI_OUT_OF_RESOURCES  - Can not allocate the memory for the IFile
+  @retval EFI_SUCCESS           - Create the new IFile for the OFile successfully
+
+**/
+EFI_STATUS
+FatAllocateIFile (
+  IN FAT_OFILE          *OFile,
+  OUT FAT_IFILE         **PtrIFile
+  );
+
+//
+// OpenVolume.c
+//
+/**
+
+  Implements Simple File System Protocol interface function OpenVolume().
+
+  @param  This                  - Calling context.
+  @param  File                  - the Root Directory of the volume.
+
+  @retval EFI_OUT_OF_RESOURCES  - Can not allocate the memory.
+  @retval EFI_VOLUME_CORRUPTED  - The FAT type is error.
+  @retval EFI_SUCCESS           - Open the volume successfully.
+
+**/
+EFI_STATUS
+EFIAPI
+FatOpenVolume (
+  IN  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *This,
+  OUT EFI_FILE_PROTOCOL               **File
+  );
+
+//
+// ReadWrite.c
+//
+/**
+
+  This function reads data from a file or writes data to a file.
+  It uses OFile->PosRem to determine how much data can be accessed in one time.
+
+  @param  OFile                 - The open file.
+  @param  IoMode                - Indicate whether the access mode is reading or writing.
+  @param  Position              - The position where data will be accessed.
+  @param  DataBufferSize        - Size of Buffer.
+  @param  UserBuffer            - Buffer containing data.
+  @param  Task                    point to task instance.
+
+  @retval EFI_SUCCESS           - Access the data successfully.
+  @return other                 - An error occurred when operating on the disk.
+
+**/
+EFI_STATUS
+FatAccessOFile (
+  IN FAT_OFILE          *OFile,
+  IN IO_MODE            IoMode,
+  IN UINTN              Position,
+  IN UINTN              *DataBufferSize,
+  IN UINT8              *UserBuffer,
+  IN FAT_TASK           *Task
+  );
+
+/**
+
+  Expand OFile by appending zero bytes at the end of OFile.
+
+  @param  OFile                 - The open file.
+  @param  ExpandedSize          - The number of zero bytes appended at the end of the file.
+
+  @retval EFI_SUCCESS           - The file is expanded successfully.
+  @return other                 - An error occurred when expanding file.
+
+**/
+EFI_STATUS
+FatExpandOFile (
+  IN FAT_OFILE          *OFile,
+  IN UINT64             ExpandedSize
+  );
+
+/**
+
+  Write zero pool from the WritePos to the end of OFile.
+
+  @param  OFile                 - The open file to write zero pool.
+  @param  WritePos              - The number of zero bytes written.
+
+  @retval EFI_SUCCESS           - Write the zero pool successfully.
+  @retval EFI_OUT_OF_RESOURCES  - Not enough memory to perform the operation.
+  @return other                 - An error occurred when writing disk.
+
+**/
+EFI_STATUS
+FatWriteZeroPool (
+  IN FAT_OFILE          *OFile,
+  IN UINTN              WritePos
+  );
+
+/**
+
+  Truncate the OFile to smaller file size.
+
+  @param  OFile                 - The open file.
+  @param  TruncatedSize         - The new file size.
+
+  @retval EFI_SUCCESS           - The file is truncated successfully.
+  @return other                 - An error occurred when truncating file.
+
+**/
+EFI_STATUS
+FatTruncateOFile (
+  IN FAT_OFILE          *OFile,
+  IN UINTN              TruncatedSize
+  );
+
+//
+// DirectoryManage.c
+//
+/**
+
+  Set the OFile's current directory cursor to the list head.
+
+  @param OFile                 - The directory OFile whose directory cursor is reset.
+
+**/
+VOID
+FatResetODirCursor (
+  IN FAT_OFILE          *OFile
+  );
+
+/**
+
+  Set the directory's cursor to the next and get the next directory entry.
+
+  @param  OFile                 - The parent OFile.
+  @param PtrDirEnt             - The next directory entry.
+
+  @retval EFI_SUCCESS           - We get the next directory entry successfully.
+  @return other                 - An error occurred when get next directory entry.
+
+**/
+EFI_STATUS
+FatGetNextDirEnt (
+  IN  FAT_OFILE         *OFile,
+  OUT FAT_DIRENT        **PtrDirEnt
+  );
+
+/**
+
+  Remove this directory entry node from the list of directory entries and hash table.
+
+  @param  OFile                - The parent OFile.
+  @param  DirEnt               - The directory entry to be removed.
+
+  @retval EFI_SUCCESS          - The directory entry is successfully removed.
+  @return other                - An error occurred when removing the directory entry.
+
+**/
+EFI_STATUS
+FatRemoveDirEnt (
+  IN FAT_OFILE          *OFile,
+  IN FAT_DIRENT         *DirEnt
+  );
+
+/**
+
+  Save the directory entry to disk.
+
+  @param  OFile                 - The parent OFile which needs to update.
+  @param  DirEnt                - The directory entry to be saved.
+
+  @retval EFI_SUCCESS           - Store the directory entry successfully.
+  @return other                 - An error occurred when writing the directory entry.
+
+**/
+EFI_STATUS
+FatStoreDirEnt (
+  IN FAT_OFILE          *OFile,
+  IN FAT_DIRENT         *DirEnt
+  );
+
+/**
+
+  Create a directory entry in the parent OFile.
+
+  @param  OFile                 - The parent OFile.
+  @param  FileName              - The filename of the newly-created directory entry.
+  @param  Attributes            - The attribute of the newly-created directory entry.
+  @param  PtrDirEnt             - The pointer to the newly-created directory entry.
+
+  @retval EFI_SUCCESS           - The directory entry is successfully created.
+  @retval EFI_OUT_OF_RESOURCES  - Not enough memory to create the directory entry.
+  @return other                 - An error occurred when creating the directory entry.
+
+**/
+EFI_STATUS
+FatCreateDirEnt (
+  IN  FAT_OFILE         *OFile,
+  IN  CHAR16            *FileName,
+  IN  UINT8             Attributes,
+  OUT FAT_DIRENT        **PtrDirEnt
+  );
+
+/**
+
+  Determine whether the directory entry is "." or ".." entry.
+
+  @param  DirEnt               - The corresponding directory entry.
+
+  @retval TRUE                 - The directory entry is "." or ".." directory entry
+  @retval FALSE                - The directory entry is not "." or ".." directory entry
+
+**/
+BOOLEAN
+FatIsDotDirEnt (
+  IN FAT_DIRENT         *DirEnt
+  );
+
+/**
+
+  Set the OFile's cluster and size info in its directory entry.
+
+  @param  OFile                 - The corresponding OFile.
+
+**/
+VOID
+FatUpdateDirEntClusterSizeInfo (
+  IN FAT_OFILE          *OFile
+  );
+
+/**
+
+  Copy all the information of DirEnt2 to DirEnt1 except for 8.3 name.
+
+  @param  DirEnt1               - The destination directory entry.
+  @param  DirEnt2               - The source directory entry.
+
+**/
+VOID
+FatCloneDirEnt (
+  IN  FAT_DIRENT        *DirEnt1,
+  IN  FAT_DIRENT        *DirEnt2
+  );
+
+/**
+
+  Get the directory entry's info into Buffer.
+
+  @param  Volume                - FAT file system volume.
+  @param  DirEnt                - The corresponding directory entry.
+  @param  BufferSize            - Size of Buffer.
+  @param  Buffer                - Buffer containing file info.
+
+  @retval EFI_SUCCESS           - Get the file info successfully.
+  @retval EFI_BUFFER_TOO_SMALL  - The buffer is too small.
+
+**/
+EFI_STATUS
+FatGetDirEntInfo (
+  IN FAT_VOLUME         *Volume,
+  IN FAT_DIRENT         *DirEnt,
+  IN OUT UINTN          *BufferSize,
+  OUT VOID              *Buffer
+  );
+
+/**
+
+  Open the directory entry to get the OFile.
+
+  @param  Parent                - The parent OFile.
+  @param  DirEnt                - The directory entry to be opened.
+
+  @retval EFI_SUCCESS           - The directory entry is successfully opened.
+  @retval EFI_OUT_OF_RESOURCES  - not enough memory to allocate a new OFile.
+  @return other                 - An error occurred when opening the directory entry.
+
+**/
+EFI_STATUS
+FatOpenDirEnt (
+  IN FAT_OFILE          *OFile,
+  IN FAT_DIRENT         *DirEnt
+  );
+
+/**
+
+  Create "." and ".." directory entries in the newly-created parent OFile.
+
+  @param  OFile                 - The parent OFile.
+
+  @retval EFI_SUCCESS           - The dot directory entries are successfully created.
+  @return other                 - An error occurred when creating the directory entry.
+
+**/
+EFI_STATUS
+FatCreateDotDirEnts (
+  IN FAT_OFILE          *OFile
+  );
+
+/**
+
+  Close the directory entry and free the OFile.
+
+  @param  DirEnt               - The directory entry to be closed.
+
+**/
+VOID
+FatCloseDirEnt (
+  IN FAT_DIRENT         *DirEnt
+  );
+
+/**
+
+  Traverse filename and open all OFiles that can be opened.
+  Update filename pointer to the component that can't be opened.
+  If more than one name component remains, returns an error;
+  otherwise, return the remaining name component so that the caller might choose to create it.
+
+  @param  PtrOFile              - As input, the reference OFile; as output, the located OFile.
+  @param  FileName              - The file name relevant to the OFile.
+  @param  Attributes            - The attribute of the destination OFile.
+  @param  NewFileName           - The remaining file name.
+
+  @retval EFI_NOT_FOUND         - The file name can't be opened and there is more than one
+                          components within the name left (this means the name can
+                          not be created either).
+  @retval EFI_INVALID_PARAMETER - The parameter is not valid.
+  @retval EFI_SUCCESS           - Open the file successfully.
+  @return other                 - An error occurred when locating the OFile.
+
+**/
+EFI_STATUS
+FatLocateOFile (
+  IN OUT FAT_OFILE      **PtrOFile,
+  IN     CHAR16         *FileName,
+  IN     UINT8          Attributes,
+     OUT CHAR16         *NewFileName
+  );
+
+/**
+
+  Get the directory entry for the volume.
+
+  @param  Volume                - FAT file system volume.
+  @param  Name                  - The file name of the volume.
+
+  @retval EFI_SUCCESS           - Update the volume with the directory entry successfully.
+  @return others                - An error occurred when getting volume label.
+
+**/
+EFI_STATUS
+FatGetVolumeEntry (
+  IN FAT_VOLUME         *Volume,
+  IN CHAR16             *Name
+  );
+
+/**
+
+  Set the relevant directory entry into disk for the volume.
+
+  @param  Volume              - FAT file system volume.
+  @param  Name                - The new file name of the volume.
+
+  @retval EFI_SUCCESS         - Update the Volume successfully.
+  @retval EFI_UNSUPPORTED     - The input label is not a valid volume label.
+  @return other               - An error occurred when setting volume label.
+
+**/
+EFI_STATUS
+FatSetVolumeEntry (
+  IN FAT_VOLUME         *Volume,
+  IN CHAR16             *Name
+  );
+
+//
+// Hash.c
+//
+/**
+
+  Search the long name hash table for the directory entry.
+
+  @param  ODir                  - The directory to be searched.
+  @param  LongNameString        - The long name string to search.
+
+  @return The previous long name hash node of the directory entry.
+
+**/
+FAT_DIRENT **
+FatLongNameHashSearch (
+  IN FAT_ODIR           *ODir,
+  IN CHAR16             *LongNameString
+  );
+
+/**
+
+  Search the short name hash table for the directory entry.
+
+  @param  ODir                  - The directory to be searched.
+  @param  ShortNameString       - The short name string to search.
+
+  @return The previous short name hash node of the directory entry.
+
+**/
+FAT_DIRENT **
+FatShortNameHashSearch (
+  IN FAT_ODIR           *ODir,
+  IN CHAR8              *ShortNameString
+  );
+
+/**
+
+  Insert directory entry to hash table.
+
+  @param  ODir                  - The parent directory.
+  @param  DirEnt                - The directory entry node.
+
+**/
+VOID
+FatInsertToHashTable (
+  IN FAT_ODIR           *ODir,
+  IN FAT_DIRENT         *DirEnt
+  );
+
+/**
+
+  Delete directory entry from hash table.
+
+  @param  ODir                  - The parent directory.
+  @param  DirEnt                - The directory entry node.
+
+**/
+VOID
+FatDeleteFromHashTable (
+  IN FAT_ODIR           *ODir,
+  IN FAT_DIRENT         *DirEnt
+  );
+
+//
+// FileName.c
+//
+/**
+
+  This function checks whether the input FileName is a valid 8.3 short name.
+  If the input FileName is a valid 8.3, the output is the 8.3 short name;
+  otherwise, the output is the base tag of 8.3 short name.
+
+  @param  FileName              - The input unicode filename.
+  @param  File8Dot3Name         - The output ascii 8.3 short name or base tag of 8.3 short name.
+
+  @retval TRUE                  - The input unicode filename is a valid 8.3 short name.
+  @retval FALSE                 - The input unicode filename is not a valid 8.3 short name.
+
+**/
+BOOLEAN
+FatCheckIs8Dot3Name (
+  IN CHAR16             *FileName,
+  OUT CHAR8             *File8Dot3Name
+  );
+
+/**
+
+  This function generates 8Dot3 name from user specified name for a newly created file.
+
+  @param  Parent                - The parent directory.
+  @param  DirEnt                - The directory entry whose 8Dot3Name needs to be generated.
+
+**/
+VOID
+FatCreate8Dot3Name (
+  IN FAT_OFILE          *Parent,
+  IN FAT_DIRENT         *DirEnt
+  );
+
+/**
+
+  Convert the ascii fat name to the unicode string and strip trailing spaces,
+  and if necessary, convert the unicode string to lower case.
+
+  @param  FatName               - The Char8 string needs to be converted.
+  @param  Len                   - The length of the fat name.
+  @param  LowerCase             - Indicate whether to convert the string to lower case.
+  @param  Str                   - The result of the conversion.
+
+**/
+VOID
+FatNameToStr (
+  IN CHAR8              *FatName,
+  IN UINTN              Len,
+  IN UINTN              LowerCase,
+  IN CHAR16             *Str
+  );
+
+/**
+
+  Set the caseflag value for the directory entry.
+
+  @param DirEnt                - The logical directory entry whose caseflag value is to be set.
+
+**/
+VOID
+FatSetCaseFlag (
+  IN FAT_DIRENT         *DirEnt
+  );
+
+/**
+
+  Convert the 8.3 ASCII fat name to cased Unicode string according to case flag.
+
+  @param  DirEnt                - The corresponding directory entry.
+  @param  FileString            - The output Unicode file name.
+  @param  FileStringMax           The max length of FileString.
+
+**/
+VOID
+FatGetFileNameViaCaseFlag (
+  IN     FAT_DIRENT     *DirEnt,
+  IN OUT CHAR16         *FileString,
+  IN     UINTN          FileStringMax
+  );
+
+/**
+
+  Get the Check sum for a short name.
+
+  @param  ShortNameString       - The short name for a file.
+
+  @retval Sum                   - UINT8 checksum.
+
+**/
+UINT8
+FatCheckSum (
+  IN CHAR8              *ShortNameString
+  );
+
+/**
+
+  Takes Path as input, returns the next name component
+  in Name, and returns the position after Name (e.g., the
+  start of the next name component)
+
+  @param  Path                  - The path of one file.
+  @param  Name                  - The next name component in Path.
+
+  The position after Name in the Path
+
+**/
+CHAR16*
+FatGetNextNameComponent (
+  IN  CHAR16            *Path,
+  OUT CHAR16            *Name
+  );
+
+/**
+
+  Check whether the IFileName is valid long file name. If the IFileName is a valid
+  long file name, then we trim the possible leading blanks and leading/trailing dots.
+  the trimmed filename is stored in OutputFileName
+
+  @param  InputFileName         - The input file name.
+  @param  OutputFileName        - The output file name.
+
+  @retval TRUE                  - The InputFileName is a valid long file name.
+  @retval FALSE                 - The InputFileName is not a valid long file name.
+
+**/
+BOOLEAN
+FatFileNameIsValid (
+  IN  CHAR16  *InputFileName,
+  OUT CHAR16  *OutputFileName
+  );
+
+//
+// DirectoryCache.c
+//
+/**
+
+  Discard the directory structure when an OFile will be freed.
+  Volume will cache this directory if the OFile does not represent a deleted file.
+
+  @param  OFile                 - The OFile whose directory structure is to be discarded.
+
+**/
+VOID
+FatDiscardODir (
+  IN FAT_OFILE    *OFile
+  );
+
+/**
+
+  Request the directory structure when an OFile is newly generated.
+  If the directory structure is cached by volume, then just return this directory;
+  Otherwise, allocate a new one for OFile.
+
+  @param  OFile                 - The OFile which requests directory structure.
+
+**/
+VOID
+FatRequestODir (
+  IN FAT_OFILE    *OFile
+  );
+
+/**
+
+  Clean up all the cached directory structures when the volume is going to be abandoned.
+
+  @param  Volume                - FAT file system volume.
+
+**/
+VOID
+FatCleanupODirCache (
+  IN FAT_VOLUME   *Volume
+  );
+
+//
+// Global Variables
+//
+extern EFI_DRIVER_BINDING_PROTOCOL     gFatDriverBinding;
+extern EFI_COMPONENT_NAME_PROTOCOL     gFatComponentName;
+extern EFI_COMPONENT_NAME2_PROTOCOL    gFatComponentName2;
+extern EFI_LOCK                        FatFsLock;
+extern EFI_LOCK                        FatTaskLock;
+extern EFI_FILE_PROTOCOL               FatFileInterface;
+
+#endif
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Fat.inf b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Fat.inf
new file mode 100644
index 00000000..a5a977a0
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Fat.inf
@@ -0,0 +1,88 @@
+## @file
+#  Component Description File for FAT module.
+#
+#  This UEFI driver detects the FAT file system in the disk.
+#  It also produces the Simple File System protocol for the consumer to
+#  perform file and directory operations on the disk.
+#  Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>
+#
+#  SPDX-License-Identifier: BSD-2-Clause-Patent
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = Fat
+  MODULE_UNI_FILE                = Fat.uni
+  FILE_GUID                      = 961578FE-B6B7-44c3-AF35-6BC705CD2B1F
+  MODULE_TYPE                    = UEFI_DRIVER
+  VERSION_STRING                 = 1.0
+
+  ENTRY_POINT                    = FatEntryPoint
+  UNLOAD_IMAGE                   = FatUnload
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64 EBC
+#
+#  DRIVER_BINDING                =  gFatDriverBinding
+#  COMPONENT_NAME                =  gFatComponentName
+#  COMPONENT_NAME2               =  gFatComponentName2
+#
+
+[Sources]
+  DirectoryCache.c
+  DiskCache.c
+  FileName.c
+  Hash.c
+  DirectoryManage.c
+  ComponentName.c
+  FatFileSystem.h
+  Fat.h
+  ReadWrite.c
+  OpenVolume.c
+  Open.c
+  Misc.c
+  Init.c
+  Info.c
+  FileSpace.c
+  Flush.c
+  Fat.c
+  Delete.c
+  Data.c
+  UnicodeCollation.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  UefiRuntimeServicesTableLib
+  UefiBootServicesTableLib
+  MemoryAllocationLib
+  BaseMemoryLib
+  BaseLib
+  UefiLib
+  UefiDriverEntryPoint
+  DebugLib
+  PcdLib
+
+[Guids]
+  gEfiFileInfoGuid                      ## SOMETIMES_CONSUMES   ## UNDEFINED
+  gEfiFileSystemInfoGuid                ## SOMETIMES_CONSUMES   ## UNDEFINED
+  gEfiFileSystemVolumeLabelInfoIdGuid   ## SOMETIMES_CONSUMES   ## UNDEFINED
+
+[Protocols]
+  gEfiDiskIoProtocolGuid                ## TO_START
+  gEfiDiskIo2ProtocolGuid               ## TO_START
+  gEfiBlockIoProtocolGuid               ## TO_START
+  gEfiSimpleFileSystemProtocolGuid      ## BY_START
+  gEfiUnicodeCollationProtocolGuid      ## TO_START
+  gEfiUnicodeCollation2ProtocolGuid     ## TO_START
+
+[Pcd]
+  gEfiMdePkgTokenSpaceGuid.PcdUefiVariableDefaultLang           ## SOMETIMES_CONSUMES
+  gEfiMdePkgTokenSpaceGuid.PcdUefiVariableDefaultPlatformLang   ## SOMETIMES_CONSUMES
+[UserExtensions.TianoCore."ExtraFiles"]
+  FatExtra.uni
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Fat.uni b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Fat.uni
new file mode 100644
index 00000000..c3d4f318
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Fat.uni
@@ -0,0 +1,18 @@
+// /** @file

+// Component description file for FAT module.

+//

+// This UEFI driver detects the FAT file system in the disk.

+// It also produces the Simple File System protocol for the consumer to

+// perform file and directory operations on the disk.

+//

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

+//

+// SPDX-License-Identifier: BSD-2-Clause-Patent

+//

+// **/

+

+

+#string STR_MODULE_ABSTRACT             #language en-US "This UEFI driver detects the FAT file system in the disk."

+

+#string STR_MODULE_DESCRIPTION          #language en-US "It also produces the Simple File System protocol for the consumer to perform file and directory operations on the disk."

+

diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/FatExtra.uni b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/FatExtra.uni
new file mode 100644
index 00000000..8f7d366a
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/FatExtra.uni
@@ -0,0 +1,14 @@
+// /** @file

+// Fat Localized Strings and Content

+//

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

+//

+// SPDX-License-Identifier: BSD-2-Clause-Patent

+//

+// **/

+

+#string STR_PROPERTIES_MODULE_NAME

+#language en-US

+"FAT File System DXE Driver"

+

+

diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/FatFileSystem.h b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/FatFileSystem.h
new file mode 100644
index 00000000..5577c5f6
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/FatFileSystem.h
@@ -0,0 +1,208 @@
+/** @file
+  Definitions for on-disk FAT structures.
+
+Copyright (c) 2005 - 2017, Intel Corporation. All rights reserved.<BR>
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+
+**/
+
+#ifndef _FATFILESYSTEM_H_
+#define _FATFILESYSTEM_H_
+
+#pragma pack(1)
+//
+// FAT info signature
+//
+#define FAT_INFO_SIGNATURE        0x41615252
+#define FAT_INFO_BEGIN_SIGNATURE  0x61417272
+#define FAT_INFO_END_SIGNATURE    0xAA550000
+//
+// FAT entry values
+//
+#define FAT_CLUSTER_SPECIAL_EXT       (MAX_UINTN & (~0xF))
+#define FAT_CLUSTER_SPECIAL           ((FAT_CLUSTER_SPECIAL_EXT) | 0x07)
+#define FAT_CLUSTER_FREE              0
+#define FAT_CLUSTER_RESERVED          (FAT_CLUSTER_SPECIAL)
+#define FAT_CLUSTER_BAD               (FAT_CLUSTER_SPECIAL)
+#define FAT_CLUSTER_LAST              (-1)
+#define FAT_END_OF_FAT_CHAIN(Cluster) ((Cluster) > (FAT_CLUSTER_SPECIAL))
+#define FAT_MIN_CLUSTER               2
+#define FAT_MAX_FAT12_CLUSTER         0xFF5
+#define FAT_MAX_FAT16_CLUSTER         0xFFF5
+#define FAT_CLUSTER_SPECIAL_FAT12     0xFF7
+#define FAT_CLUSTER_SPECIAL_FAT16     0xFFF7
+#define FAT_CLUSTER_SPECIAL_FAT32     0x0FFFFFF7
+#define FAT_CLUSTER_MASK_FAT12        0xFFF
+#define FAT_CLUSTER_UNMASK_FAT12      0xF000
+#define FAT_CLUSTER_MASK_FAT32        0x0FFFFFFF
+#define FAT_CLUSTER_UNMASK_FAT32      0xF0000000
+#define FAT_POS_FAT12(a)              ((a) * 3 / 2)
+#define FAT_POS_FAT16(a)              ((a) * 2)
+#define FAT_POS_FAT32(a)              ((a) * 4)
+#define FAT_ODD_CLUSTER_FAT12(a)      (((a) & 1) != 0)
+
+
+//
+// FAT attribute define
+//
+#define FAT_ATTRIBUTE_READ_ONLY 0x01
+#define FAT_ATTRIBUTE_HIDDEN    0x02
+#define FAT_ATTRIBUTE_SYSTEM    0x04
+#define FAT_ATTRIBUTE_VOLUME_ID 0x08
+#define FAT_ATTRIBUTE_DIRECTORY 0x10
+#define FAT_ATTRIBUTE_ARCHIVE   0x20
+#define FAT_ATTRIBUTE_DEVICE    0x40
+#define FAT_ATTRIBUTE_LFN       0x0F
+//
+// Some Long File Name definitions
+//
+#define FAT_LFN_LAST            0x40  // Ordinal field
+#define MAX_LFN_ENTRIES         20
+#define LFN_CHAR1_LEN           5
+#define LFN_CHAR2_LEN           6
+#define LFN_CHAR3_LEN           2
+#define LFN_CHAR_TOTAL          (LFN_CHAR1_LEN + LFN_CHAR2_LEN + LFN_CHAR3_LEN)
+#define LFN_ENTRY_NUMBER(a)     (((a) + LFN_CHAR_TOTAL - 1) / LFN_CHAR_TOTAL)
+//
+// Some 8.3 File Name definitions
+//
+#define FAT_MAIN_NAME_LEN       8
+#define FAT_EXTEND_NAME_LEN     3
+#define FAT_NAME_LEN            (FAT_MAIN_NAME_LEN + FAT_EXTEND_NAME_LEN)
+//
+// Some directory entry information
+//
+#define FAT_ENTRY_INFO_OFFSET   13
+#define DELETE_ENTRY_MARK       0xE5
+#define EMPTY_ENTRY_MARK        0x00
+
+//
+// Volume dirty Mask
+//
+#define FAT16_DIRTY_MASK        0x7fff
+#define FAT32_DIRTY_MASK        0xf7ffffff
+//
+// internal flag
+//
+#define FAT_CASE_MIXED          0x01
+#define FAT_CASE_NAME_LOWER     0x08
+#define FAT_CASE_EXT_LOWER      0x10
+
+typedef struct {
+  UINT8   Ia32Jump[3];
+  CHAR8   OemId[8];
+  UINT16  SectorSize;
+  UINT8   SectorsPerCluster;
+  UINT16  ReservedSectors;
+  UINT8   NumFats;
+  UINT16  RootEntries;          // < FAT32, root dir is fixed size
+  UINT16  Sectors;
+  UINT8   Media;
+  UINT16  SectorsPerFat;        // < FAT32
+  UINT16  SectorsPerTrack;      // (ignored)
+  UINT16  Heads;                // (ignored)
+  UINT32  HiddenSectors;        // (ignored)
+  UINT32  LargeSectors;         // Used if Sectors==0
+} FAT_BOOT_SECTOR_BASIC;
+
+typedef struct {
+  UINT8 PhysicalDriveNumber;    // (ignored)
+  UINT8 CurrentHead;            // holds boot_sector_dirty bit
+  UINT8 Signature;              // (ignored)
+  CHAR8 Id[4];
+  CHAR8 FatLabel[11];
+  CHAR8 SystemId[8];
+} FAT_BOOT_SECTOR_EXT;
+
+typedef struct {
+  UINT32  LargeSectorsPerFat;   // FAT32
+  UINT16  ExtendedFlags;        // FAT32 (ignored)
+  UINT16  FsVersion;            // FAT32 (ignored)
+  UINT32  RootDirFirstCluster;  // FAT32
+  UINT16  FsInfoSector;         // FAT32
+  UINT16  BackupBootSector;     // FAT32
+  UINT8   Reserved[12];         // FAT32 (ignored)
+  UINT8   PhysicalDriveNumber;  // (ignored)
+  UINT8   CurrentHead;          // holds boot_sector_dirty bit
+  UINT8   Signature;            // (ignored)
+  CHAR8   Id[4];
+  CHAR8   FatLabel[11];
+  CHAR8   SystemId[8];
+} FAT32_BOOT_SECTOR_EXT;
+
+typedef union {
+    FAT_BOOT_SECTOR_EXT   FatBse;
+    FAT32_BOOT_SECTOR_EXT Fat32Bse;
+  } FAT_BSE;
+
+typedef struct {
+  FAT_BOOT_SECTOR_BASIC   FatBsb;
+  FAT_BSE  FatBse;
+} FAT_BOOT_SECTOR;
+
+//
+// FAT Info Structure
+//
+typedef struct {
+  UINT32  ClusterCount;
+  UINT32  NextCluster;
+} FAT_FREE_INFO;
+
+typedef struct {
+  UINT32        Signature;
+  UINT8         ExtraBootCode[480];
+  UINT32        InfoBeginSignature;
+  FAT_FREE_INFO FreeInfo;
+  UINT8         Reserved[12];
+  UINT32        InfoEndSignature;
+} FAT_INFO_SECTOR;
+
+//
+// Directory Entry
+//
+#define FAT_MAX_YEAR_FROM_1980  0x7f
+typedef struct {
+  UINT16  Day : 5;
+  UINT16  Month : 4;
+  UINT16  Year : 7;                 // From 1980
+} FAT_DATE;
+
+typedef struct {
+  UINT16  DoubleSecond : 5;
+  UINT16  Minute : 6;
+  UINT16  Hour : 5;
+} FAT_TIME;
+
+typedef struct {
+  FAT_TIME  Time;
+  FAT_DATE  Date;
+} FAT_DATE_TIME;
+
+typedef struct {
+  CHAR8         FileName[11];       // 8.3 filename
+  UINT8         Attributes;
+  UINT8         CaseFlag;
+  UINT8         CreateMillisecond;  // (creation milliseconds - ignored)
+  FAT_DATE_TIME FileCreateTime;
+  FAT_DATE      FileLastAccess;
+  UINT16        FileClusterHigh;    // >= FAT32
+  FAT_DATE_TIME FileModificationTime;
+  UINT16        FileCluster;
+  UINT32        FileSize;
+} FAT_DIRECTORY_ENTRY;
+
+typedef struct {
+  UINT8   Ordinal;
+  CHAR8   Name1[10];                // (Really 5 chars, but not WCHAR aligned)
+  UINT8   Attributes;
+  UINT8   Type;
+  UINT8   Checksum;
+  CHAR16  Name2[6];
+  UINT16  MustBeZero;
+  CHAR16  Name3[2];
+} FAT_DIRECTORY_LFN;
+
+#pragma pack()
+
+#endif
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/FileName.c b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/FileName.c
new file mode 100644
index 00000000..a23adb09
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/FileName.c
@@ -0,0 +1,499 @@
+/** @file
+  Functions for manipulating file names.
+
+Copyright (c) 2005 - 2015, Intel Corporation. All rights reserved.<BR>
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "Fat.h"
+
+/**
+
+  This function checks whether the input FileName is a valid 8.3 short name.
+  If the input FileName is a valid 8.3, the output is the 8.3 short name;
+  otherwise, the output is the base tag of 8.3 short name.
+
+  @param  FileName              - The input unicode filename.
+  @param  File8Dot3Name         - The output ascii 8.3 short name or base tag of 8.3 short name.
+
+  @retval TRUE                  - The input unicode filename is a valid 8.3 short name.
+  @retval FALSE                 - The input unicode filename is not a valid 8.3 short name.
+
+**/
+BOOLEAN
+FatCheckIs8Dot3Name (
+  IN  CHAR16    *FileName,
+  OUT CHAR8     *File8Dot3Name
+  )
+{
+  BOOLEAN PossibleShortName;
+  CHAR16  *TempName;
+  CHAR16  *ExtendName;
+  CHAR16  *SeparateDot;
+  UINTN   MainNameLen;
+  UINTN   ExtendNameLen;
+
+  PossibleShortName = TRUE;
+  SeparateDot       = NULL;
+  SetMem (File8Dot3Name, FAT_NAME_LEN, ' ');
+  for (TempName = FileName; *TempName != '\0'; TempName++) {
+    if (*TempName == L'.') {
+      SeparateDot = TempName;
+    }
+  }
+
+  if (SeparateDot == NULL) {
+    //
+    // Extended filename is not detected
+    //
+    MainNameLen   = TempName - FileName;
+    ExtendName    = TempName;
+    ExtendNameLen = 0;
+  } else {
+    //
+    // Extended filename is detected
+    //
+    MainNameLen   = SeparateDot - FileName;
+    ExtendName    = SeparateDot + 1;
+    ExtendNameLen = TempName - ExtendName;
+  }
+  //
+  // We scan the filename for the second time
+  // to check if there exists any extra blanks and dots
+  //
+  while (--TempName >= FileName) {
+    if ((*TempName == L'.' || *TempName == L' ') && (TempName != SeparateDot)) {
+      //
+      // There exist extra blanks and dots
+      //
+      PossibleShortName = FALSE;
+    }
+  }
+
+  if (MainNameLen == 0) {
+    PossibleShortName = FALSE;
+  }
+
+  if (MainNameLen > FAT_MAIN_NAME_LEN) {
+    PossibleShortName = FALSE;
+    MainNameLen       = FAT_MAIN_NAME_LEN;
+  }
+
+  if (ExtendNameLen > FAT_EXTEND_NAME_LEN) {
+    PossibleShortName = FALSE;
+    ExtendNameLen     = FAT_EXTEND_NAME_LEN;
+  }
+
+  if (FatStrToFat (FileName, MainNameLen, File8Dot3Name)) {
+    PossibleShortName = FALSE;
+  }
+
+  if (FatStrToFat (ExtendName, ExtendNameLen, File8Dot3Name + FAT_MAIN_NAME_LEN)) {
+    PossibleShortName = FALSE;
+  }
+
+  return PossibleShortName;
+}
+
+/**
+
+  Trim the trailing blanks of fat name.
+
+  @param  Name                  - The Char8 string needs to be trimmed.
+  @param  Len                   - The length of the fat name.
+
+  The real length of the fat name after the trailing blanks are trimmed.
+
+**/
+STATIC
+UINTN
+FatTrimAsciiTrailingBlanks (
+  IN CHAR8        *Name,
+  IN UINTN        Len
+  )
+{
+  while (Len > 0 && Name[Len - 1] == ' ') {
+    Len--;
+  }
+
+  return Len;
+}
+
+/**
+
+  Convert the ascii fat name to the unicode string and strip trailing spaces,
+  and if necessary, convert the unicode string to lower case.
+
+  @param  FatName               - The Char8 string needs to be converted.
+  @param  Len                   - The length of the fat name.
+  @param  LowerCase             - Indicate whether to convert the string to lower case.
+  @param  Str                   - The result of the conversion.
+
+**/
+VOID
+FatNameToStr (
+  IN  CHAR8            *FatName,
+  IN  UINTN            Len,
+  IN  UINTN            LowerCase,
+  OUT CHAR16           *Str
+  )
+{
+  //
+  // First, trim the trailing blanks
+  //
+  Len = FatTrimAsciiTrailingBlanks (FatName, Len);
+  //
+  // Convert fat string to unicode string
+  //
+  FatFatToStr (Len, FatName, Str);
+
+  //
+  // If the name is to be lower cased, do it now
+  //
+  if (LowerCase != 0) {
+    FatStrLwr (Str);
+  }
+}
+
+/**
+
+  This function generates 8Dot3 name from user specified name for a newly created file.
+
+  @param  Parent                - The parent directory.
+  @param  DirEnt                - The directory entry whose 8Dot3Name needs to be generated.
+
+**/
+VOID
+FatCreate8Dot3Name (
+  IN FAT_OFILE    *Parent,
+  IN FAT_DIRENT   *DirEnt
+  )
+{
+  CHAR8 *ShortName;
+  CHAR8 *ShortNameChar;
+  UINTN BaseTagLen;
+  UINTN Index;
+  UINTN Retry;
+  UINT8 Segment;
+  union {
+    UINT32  Crc;
+    struct HEX_DATA {
+      UINT8 Segment : HASH_VALUE_TAG_LEN;
+    } Hex[HASH_VALUE_TAG_LEN];
+  } HashValue;
+  //
+  // Make sure the whole directory has been loaded
+  //
+  ASSERT (Parent->ODir->EndOfDir);
+  ShortName = DirEnt->Entry.FileName;
+
+  //
+  // Trim trailing blanks of 8.3 name
+  //
+  BaseTagLen = FatTrimAsciiTrailingBlanks (ShortName, FAT_MAIN_NAME_LEN);
+  if (BaseTagLen > SPEC_BASE_TAG_LEN) {
+    BaseTagLen = SPEC_BASE_TAG_LEN;
+  }
+  //
+  // We first use the algorithm described by spec.
+  //
+  ShortNameChar     = ShortName + BaseTagLen;
+  *ShortNameChar++  = '~';
+  *ShortNameChar    = '1';
+  Retry = 0;
+  while (*FatShortNameHashSearch (Parent->ODir, ShortName) != NULL) {
+    *ShortNameChar = (CHAR8)(*ShortNameChar + 1);
+    if (++Retry == MAX_SPEC_RETRY) {
+      //
+      // We use new algorithm to generate 8.3 name
+      //
+      ASSERT (DirEnt->FileString != NULL);
+      gBS->CalculateCrc32 (DirEnt->FileString, StrSize (DirEnt->FileString), &HashValue.Crc);
+
+      if (BaseTagLen > HASH_BASE_TAG_LEN) {
+        BaseTagLen = HASH_BASE_TAG_LEN;
+      }
+
+      ShortNameChar = ShortName + BaseTagLen;
+      for (Index = 0; Index < HASH_VALUE_TAG_LEN; Index++) {
+        Segment = HashValue.Hex[Index].Segment;
+        if (Segment > 9) {
+          *ShortNameChar++ = (CHAR8)(Segment - 10 + 'A');
+        } else {
+          *ShortNameChar++ = (CHAR8)(Segment + '0');
+        }
+      }
+
+      *ShortNameChar++  = '~';
+      *ShortNameChar    = '1';
+    }
+  }
+}
+
+/**
+
+  Check the string is lower case or upper case
+  and it is used by fatname to dir entry count
+
+  @param Str                   - The string which needs to be checked.
+  @param InCaseFlag            - The input case flag which is returned when the string is lower case.
+
+  @retval OutCaseFlag           - The output case flag.
+
+**/
+STATIC
+UINT8
+FatCheckNameCase (
+  IN CHAR16           *Str,
+  IN UINT8            InCaseFlag
+  )
+{
+  CHAR16  Buffer[FAT_MAIN_NAME_LEN + 1 + FAT_EXTEND_NAME_LEN + 1];
+  UINT8   OutCaseFlag;
+
+  //
+  // Assume the case of input string is mixed
+  //
+  OutCaseFlag = FAT_CASE_MIXED;
+  //
+  // Lower case a copy of the string, if it matches the
+  // original then the string is lower case
+  //
+  StrCpyS (Buffer, ARRAY_SIZE (Buffer), Str);
+  FatStrLwr (Buffer);
+  if (StrCmp (Str, Buffer) == 0) {
+    OutCaseFlag = InCaseFlag;
+  }
+  //
+  // Upper case a copy of the string, if it matches the
+  // original then the string is upper case
+  //
+  StrCpyS (Buffer, ARRAY_SIZE (Buffer), Str);
+  FatStrUpr (Buffer);
+  if (StrCmp (Str, Buffer) == 0) {
+    OutCaseFlag = 0;
+  }
+
+  return OutCaseFlag;
+}
+
+/**
+
+  Set the caseflag value for the directory entry.
+
+  @param DirEnt                - The logical directory entry whose caseflag value is to be set.
+
+**/
+VOID
+FatSetCaseFlag (
+  IN FAT_DIRENT   *DirEnt
+  )
+{
+  CHAR16  LfnBuffer[FAT_MAIN_NAME_LEN + 1 + FAT_EXTEND_NAME_LEN + 1];
+  CHAR16  *TempCharPtr;
+  CHAR16  *ExtendName;
+  CHAR16  *FileNameCharPtr;
+  UINT8   CaseFlag;
+
+  ExtendName      = NULL;
+  TempCharPtr     = LfnBuffer;
+  FileNameCharPtr = DirEnt->FileString;
+  ASSERT (StrSize (DirEnt->FileString) <= sizeof (LfnBuffer));
+  while ((*TempCharPtr = *FileNameCharPtr) != 0) {
+    if (*TempCharPtr == L'.') {
+      ExtendName = TempCharPtr;
+    }
+
+    TempCharPtr++;
+    FileNameCharPtr++;
+  }
+
+  CaseFlag = 0;
+  if (ExtendName != NULL) {
+    *ExtendName = 0;
+    ExtendName++;
+    CaseFlag = (UINT8)(CaseFlag | FatCheckNameCase (ExtendName, FAT_CASE_EXT_LOWER));
+  }
+
+  CaseFlag = (UINT8)(CaseFlag | FatCheckNameCase (LfnBuffer, FAT_CASE_NAME_LOWER));
+  if ((CaseFlag & FAT_CASE_MIXED) == 0) {
+    //
+    // We just need one directory entry to store this file name entry
+    //
+    DirEnt->Entry.CaseFlag = CaseFlag;
+  } else {
+    //
+    // We need one extra directory entry to store the mixed case entry
+    //
+    DirEnt->Entry.CaseFlag = 0;
+    DirEnt->EntryCount++;
+  }
+}
+
+/**
+
+  Convert the 8.3 ASCII fat name to cased Unicode string according to case flag.
+
+  @param  DirEnt                - The corresponding directory entry.
+  @param  FileString            - The output Unicode file name.
+  @param  FileStringMax           The max length of FileString.
+
+**/
+VOID
+FatGetFileNameViaCaseFlag (
+  IN     FAT_DIRENT   *DirEnt,
+  IN OUT CHAR16       *FileString,
+  IN     UINTN        FileStringMax
+  )
+{
+  UINT8   CaseFlag;
+  CHAR8   *File8Dot3Name;
+  CHAR16  TempExt[1 + FAT_EXTEND_NAME_LEN + 1];
+  //
+  // Store file extension like ".txt"
+  //
+  CaseFlag      = DirEnt->Entry.CaseFlag;
+  File8Dot3Name = DirEnt->Entry.FileName;
+
+  FatNameToStr (File8Dot3Name, FAT_MAIN_NAME_LEN, CaseFlag & FAT_CASE_NAME_LOWER, FileString);
+  FatNameToStr (File8Dot3Name + FAT_MAIN_NAME_LEN, FAT_EXTEND_NAME_LEN, CaseFlag & FAT_CASE_EXT_LOWER, &TempExt[1]);
+  if (TempExt[1] != 0) {
+    TempExt[0] = L'.';
+    StrCatS (FileString, FileStringMax, TempExt);
+  }
+}
+
+/**
+
+  Get the Check sum for a short name.
+
+  @param  ShortNameString       - The short name for a file.
+
+  @retval Sum                   - UINT8 checksum.
+
+**/
+UINT8
+FatCheckSum (
+  IN CHAR8  *ShortNameString
+  )
+{
+  UINTN ShortNameLen;
+  UINT8 Sum;
+  Sum = 0;
+  for (ShortNameLen = FAT_NAME_LEN; ShortNameLen != 0; ShortNameLen--) {
+    Sum = (UINT8)((((Sum & 1) != 0) ? 0x80 : 0) + (Sum >> 1) + *ShortNameString++);
+  }
+
+  return Sum;
+}
+
+/**
+
+  Takes Path as input, returns the next name component
+  in Name, and returns the position after Name (e.g., the
+  start of the next name component)
+
+  @param  Path                  - The path of one file.
+  @param  Name                  - The next name component in Path.
+
+  The position after Name in the Path
+
+**/
+CHAR16 *
+FatGetNextNameComponent (
+  IN  CHAR16      *Path,
+  OUT CHAR16      *Name
+  )
+{
+  while (*Path != 0 && *Path != PATH_NAME_SEPARATOR) {
+    *Name++ = *Path++;
+  }
+  *Name = 0;
+  //
+  // Get off of trailing path name separator
+  //
+  while (*Path == PATH_NAME_SEPARATOR) {
+    Path++;
+  }
+
+  return Path;
+}
+
+/**
+
+  Check whether the IFileName is valid long file name. If the IFileName is a valid
+  long file name, then we trim the possible leading blanks and leading/trailing dots.
+  the trimmed filename is stored in OutputFileName
+
+  @param  InputFileName         - The input file name.
+  @param  OutputFileName        - The output file name.
+
+  @retval TRUE                  - The InputFileName is a valid long file name.
+  @retval FALSE                 - The InputFileName is not a valid long file name.
+
+**/
+BOOLEAN
+FatFileNameIsValid (
+  IN  CHAR16  *InputFileName,
+  OUT CHAR16  *OutputFileName
+  )
+{
+  CHAR16  *TempNamePointer;
+  CHAR16  TempChar;
+  //
+  // Trim Leading blanks
+  //
+  while (*InputFileName == L' ') {
+    InputFileName++;
+  }
+
+  TempNamePointer = OutputFileName;
+  while (*InputFileName != 0) {
+    *TempNamePointer++ = *InputFileName++;
+  }
+  //
+  // Trim Trailing blanks and dots
+  //
+  while (TempNamePointer > OutputFileName) {
+    TempChar = *(TempNamePointer - 1);
+    if (TempChar != L' ' && TempChar != L'.') {
+      break;
+    }
+
+    TempNamePointer--;
+  }
+
+  *TempNamePointer = 0;
+
+  //
+  // Per FAT Spec the file name should meet the following criteria:
+  //   C1. Length (FileLongName) <= 255
+  //   C2. Length (X:FileFullPath<NUL>) <= 260
+  // Here we check C1.
+  //
+  if (TempNamePointer - OutputFileName > EFI_FILE_STRING_LENGTH) {
+    return FALSE;
+  }
+  //
+  // See if there is any illegal characters within the name
+  //
+  do {
+    if (*OutputFileName < 0x20 ||
+        *OutputFileName == '\"' ||
+        *OutputFileName == '*' ||
+        *OutputFileName == '/' ||
+        *OutputFileName == ':' ||
+        *OutputFileName == '<' ||
+        *OutputFileName == '>' ||
+        *OutputFileName == '?' ||
+        *OutputFileName == '\\' ||
+        *OutputFileName == '|'
+        ) {
+      return FALSE;
+    }
+
+    OutputFileName++;
+  } while (*OutputFileName != 0);
+  return TRUE;
+}
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/FileSpace.c b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/FileSpace.c
new file mode 100644
index 00000000..78b26a58
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/FileSpace.c
@@ -0,0 +1,744 @@
+/** @file
+  Routines dealing with disk spaces and FAT table entries.
+
+Copyright (c) 2005 - 2013, Intel Corporation. All rights reserved.<BR>
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+
+
+**/
+
+#include "Fat.h"
+
+
+/**
+
+  Get the FAT entry of the volume, which is identified with the Index.
+
+  @param  Volume                - FAT file system volume.
+  @param  Index                 - The index of the FAT entry of the volume.
+
+  @return The buffer of the FAT entry
+
+**/
+STATIC
+VOID *
+FatLoadFatEntry (
+  IN FAT_VOLUME       *Volume,
+  IN UINTN            Index
+  )
+{
+  UINTN       Pos;
+  EFI_STATUS  Status;
+
+  if (Index > (Volume->MaxCluster + 1)) {
+    Volume->FatEntryBuffer = (UINT32) -1;
+    return &Volume->FatEntryBuffer;
+  }
+  //
+  // Compute buffer position needed
+  //
+  switch (Volume->FatType) {
+  case Fat12:
+    Pos = FAT_POS_FAT12 (Index);
+    break;
+
+  case Fat16:
+    Pos = FAT_POS_FAT16 (Index);
+    break;
+
+  default:
+    Pos = FAT_POS_FAT32 (Index);
+  }
+  //
+  // Set the position and read the buffer
+  //
+  Volume->FatEntryPos = Volume->FatPos + Pos;
+  Status = FatDiskIo (
+             Volume,
+             ReadFat,
+             Volume->FatEntryPos,
+             Volume->FatEntrySize,
+             &Volume->FatEntryBuffer,
+             NULL
+             );
+  if (EFI_ERROR (Status)) {
+    Volume->FatEntryBuffer = (UINT32) -1;
+  }
+
+  return &Volume->FatEntryBuffer;
+}
+
+/**
+
+  Get the FAT entry value of the volume, which is identified with the Index.
+
+  @param  Volume                - FAT file system volume.
+  @param  Index                 - The index of the FAT entry of the volume.
+
+  @return  The value of the FAT entry.
+
+**/
+STATIC
+UINTN
+FatGetFatEntry (
+  IN FAT_VOLUME       *Volume,
+  IN UINTN            Index
+  )
+{
+  VOID    *Pos;
+  UINT8   *En12;
+  UINT16  *En16;
+  UINT32  *En32;
+  UINTN   Accum;
+
+  Pos = FatLoadFatEntry (Volume, Index);
+
+  if (Index > (Volume->MaxCluster + 1)) {
+    return (UINTN) -1;
+  }
+
+  switch (Volume->FatType) {
+  case Fat12:
+    En12   = Pos;
+    Accum = En12[0] | (En12[1] << 8);
+    Accum = FAT_ODD_CLUSTER_FAT12 (Index) ? (Accum >> 4) : (Accum & FAT_CLUSTER_MASK_FAT12);
+    Accum = Accum | ((Accum >= FAT_CLUSTER_SPECIAL_FAT12) ? FAT_CLUSTER_SPECIAL_EXT : 0);
+    break;
+
+  case Fat16:
+    En16   = Pos;
+    Accum = *En16;
+    Accum = Accum | ((Accum >= FAT_CLUSTER_SPECIAL_FAT16) ? FAT_CLUSTER_SPECIAL_EXT : 0);
+    break;
+
+  default:
+    En32   = Pos;
+    Accum = *En32 & FAT_CLUSTER_MASK_FAT32;
+    Accum = Accum | ((Accum >= FAT_CLUSTER_SPECIAL_FAT32) ? FAT_CLUSTER_SPECIAL_EXT : 0);
+  }
+
+  return Accum;
+}
+
+/**
+
+  Set the FAT entry value of the volume, which is identified with the Index.
+
+  @param  Volume                - FAT file system volume.
+  @param  Index                 - The index of the FAT entry of the volume.
+  @param  Value                 - The new value of the FAT entry.
+
+  @retval EFI_SUCCESS           - Set the new FAT entry value successfully.
+  @retval EFI_VOLUME_CORRUPTED  - The FAT type of the volume is error.
+  @return other                 - An error occurred when operation the FAT entries.
+
+**/
+STATIC
+EFI_STATUS
+FatSetFatEntry (
+  IN FAT_VOLUME       *Volume,
+  IN UINTN            Index,
+  IN UINTN            Value
+  )
+{
+  VOID        *Pos;
+  UINT8       *En12;
+  UINT16      *En16;
+  UINT32      *En32;
+  UINTN       Accum;
+  EFI_STATUS  Status;
+  UINTN       OriginalVal;
+
+  if (Index < FAT_MIN_CLUSTER) {
+    return EFI_VOLUME_CORRUPTED;
+  }
+
+  OriginalVal = FatGetFatEntry (Volume, Index);
+  if (Value == FAT_CLUSTER_FREE && OriginalVal != FAT_CLUSTER_FREE) {
+    Volume->FatInfoSector.FreeInfo.ClusterCount += 1;
+    if (Index < Volume->FatInfoSector.FreeInfo.NextCluster) {
+      Volume->FatInfoSector.FreeInfo.NextCluster = (UINT32) Index;
+    }
+  } else if (Value != FAT_CLUSTER_FREE && OriginalVal == FAT_CLUSTER_FREE) {
+    if (Volume->FatInfoSector.FreeInfo.ClusterCount != 0) {
+      Volume->FatInfoSector.FreeInfo.ClusterCount -= 1;
+    }
+  }
+  //
+  // Make sure the entry is in memory
+  //
+  Pos = FatLoadFatEntry (Volume, Index);
+
+  //
+  // Update the value
+  //
+  switch (Volume->FatType) {
+  case Fat12:
+    En12   = Pos;
+    Accum = En12[0] | (En12[1] << 8);
+    Value = Value & FAT_CLUSTER_MASK_FAT12;
+
+    if (FAT_ODD_CLUSTER_FAT12 (Index)) {
+      Accum = (Value << 4) | (Accum & 0xF);
+    } else {
+      Accum = Value | (Accum & FAT_CLUSTER_UNMASK_FAT12);
+    }
+
+    En12[0]  = (UINT8) (Accum & 0xFF);
+    En12[1]  = (UINT8) (Accum >> 8);
+    break;
+
+  case Fat16:
+    En16   = Pos;
+    *En16  = (UINT16) Value;
+    break;
+
+  default:
+    En32   = Pos;
+    *En32  = (*En32 & FAT_CLUSTER_UNMASK_FAT32) | (UINT32) (Value & FAT_CLUSTER_MASK_FAT32);
+  }
+  //
+  // If the volume's dirty bit is not set, set it now
+  //
+  if (!Volume->FatDirty && Volume->FatType != Fat12) {
+    Volume->FatDirty = TRUE;
+    FatAccessVolumeDirty (Volume, WriteFat, &Volume->DirtyValue);
+  }
+  //
+  // Write the updated fat entry value to the volume
+  // The fat is the first fat, and other fat will be in sync
+  // when the FAT cache flush back.
+  //
+  Status = FatDiskIo (
+             Volume,
+             WriteFat,
+             Volume->FatEntryPos,
+             Volume->FatEntrySize,
+             &Volume->FatEntryBuffer,
+             NULL
+             );
+  return Status;
+}
+
+/**
+
+  Free the cluster chain.
+
+  @param  Volume                - FAT file system volume.
+  @param  Cluster               - The first cluster of cluster chain.
+
+  @retval EFI_SUCCESS           - The cluster chain is freed successfully.
+  @retval EFI_VOLUME_CORRUPTED  - There are errors in the file's clusters.
+
+**/
+STATIC
+EFI_STATUS
+FatFreeClusters (
+  IN FAT_VOLUME           *Volume,
+  IN UINTN                Cluster
+  )
+{
+  UINTN LastCluster;
+
+  while (!FAT_END_OF_FAT_CHAIN (Cluster)) {
+    if (Cluster == FAT_CLUSTER_FREE || Cluster >= FAT_CLUSTER_SPECIAL) {
+
+      DEBUG ((EFI_D_INIT | EFI_D_ERROR, "FatShrinkEof: cluster chain corrupt\n"));
+      return EFI_VOLUME_CORRUPTED;
+    }
+
+    LastCluster = Cluster;
+    Cluster     = FatGetFatEntry (Volume, Cluster);
+    FatSetFatEntry (Volume, LastCluster, FAT_CLUSTER_FREE);
+  }
+
+  return EFI_SUCCESS;
+}
+
+/**
+
+  Allocate a free cluster and return the cluster index.
+
+  @param  Volume                - FAT file system volume.
+
+  @return The index of the free cluster
+
+**/
+STATIC
+UINTN
+FatAllocateCluster (
+  IN FAT_VOLUME   *Volume
+  )
+{
+  UINTN Cluster;
+
+  //
+  // Start looking at FatFreePos for the next unallocated cluster
+  //
+  if (Volume->DiskError) {
+    return (UINTN) FAT_CLUSTER_LAST;
+  }
+
+  for (;;) {
+    //
+    // If the end of the list, return no available cluster
+    //
+    if (Volume->FatInfoSector.FreeInfo.NextCluster > (Volume->MaxCluster + 1)) {
+      if (Volume->FreeInfoValid && 0 < (INT32) (Volume->FatInfoSector.FreeInfo.ClusterCount)) {
+        Volume->FreeInfoValid = FALSE;
+      }
+
+      FatComputeFreeInfo (Volume);
+      if (Volume->FatInfoSector.FreeInfo.NextCluster > (Volume->MaxCluster + 1)) {
+        return (UINTN) FAT_CLUSTER_LAST;
+      }
+    }
+
+    Cluster = FatGetFatEntry (Volume, Volume->FatInfoSector.FreeInfo.NextCluster);
+    if (Cluster == FAT_CLUSTER_FREE) {
+      break;
+    }
+    //
+    // Try the next cluster
+    //
+    Volume->FatInfoSector.FreeInfo.NextCluster += 1;
+  }
+
+  Cluster = Volume->FatInfoSector.FreeInfo.NextCluster;
+  Volume->FatInfoSector.FreeInfo.NextCluster += 1;
+  return Cluster;
+}
+
+/**
+
+  Count the number of clusters given a size.
+
+  @param  Volume                - The file system volume.
+  @param  Size                  - The size in bytes.
+
+  @return The number of the clusters.
+
+**/
+STATIC
+UINTN
+FatSizeToClusters (
+  IN FAT_VOLUME       *Volume,
+  IN UINTN            Size
+  )
+{
+  UINTN Clusters;
+
+  Clusters = Size >> Volume->ClusterAlignment;
+  if ((Size & (Volume->ClusterSize - 1)) > 0) {
+    Clusters += 1;
+  }
+
+  return Clusters;
+}
+
+/**
+
+  Shrink the end of the open file base on the file size.
+
+  @param  OFile                 - The open file.
+
+  @retval EFI_SUCCESS           - Shrinked successfully.
+  @retval EFI_VOLUME_CORRUPTED  - There are errors in the file's clusters.
+
+**/
+EFI_STATUS
+FatShrinkEof (
+  IN FAT_OFILE            *OFile
+  )
+{
+  FAT_VOLUME  *Volume;
+  UINTN       NewSize;
+  UINTN       CurSize;
+  UINTN       Cluster;
+  UINTN       LastCluster;
+
+  Volume  = OFile->Volume;
+  ASSERT_VOLUME_LOCKED (Volume);
+
+  NewSize = FatSizeToClusters (Volume, OFile->FileSize);
+
+  //
+  // Find the address of the last cluster
+  //
+  Cluster     = OFile->FileCluster;
+  LastCluster = FAT_CLUSTER_FREE;
+
+  if (NewSize != 0) {
+
+    for (CurSize = 0; CurSize < NewSize; CurSize++) {
+      if (Cluster == FAT_CLUSTER_FREE || Cluster >= FAT_CLUSTER_SPECIAL) {
+
+        DEBUG ((EFI_D_INIT | EFI_D_ERROR, "FatShrinkEof: cluster chain corrupt\n"));
+        return EFI_VOLUME_CORRUPTED;
+      }
+
+      LastCluster = Cluster;
+      Cluster     = FatGetFatEntry (Volume, Cluster);
+    }
+
+    FatSetFatEntry (Volume, LastCluster, (UINTN) FAT_CLUSTER_LAST);
+
+  } else {
+    //
+    // Check to see if the file is already completely truncated
+    //
+    if (Cluster == FAT_CLUSTER_FREE) {
+      return EFI_SUCCESS;
+    }
+    //
+    // The file is being completely truncated.
+    //
+    OFile->FileCluster      = FAT_CLUSTER_FREE;
+  }
+  //
+  // Set CurrentCluster == FileCluster
+  // to force a recalculation of Position related stuffs
+  //
+  OFile->FileCurrentCluster = OFile->FileCluster;
+  OFile->FileLastCluster    = LastCluster;
+  OFile->Dirty              = TRUE;
+  //
+  // Free the remaining cluster chain
+  //
+  return FatFreeClusters (Volume, Cluster);
+}
+
+/**
+
+  Grow the end of the open file base on the NewSizeInBytes.
+
+  @param  OFile                 - The open file.
+  @param  NewSizeInBytes        - The new size in bytes of the open file.
+
+  @retval EFI_SUCCESS           - The file is grown successfully.
+  @retval EFI_UNSUPPORTED       - The file size is larger than 4GB.
+  @retval EFI_VOLUME_CORRUPTED  - There are errors in the files' clusters.
+  @retval EFI_VOLUME_FULL       - The volume is full and can not grow the file.
+
+**/
+EFI_STATUS
+FatGrowEof (
+  IN FAT_OFILE            *OFile,
+  IN UINT64               NewSizeInBytes
+  )
+{
+  FAT_VOLUME  *Volume;
+  EFI_STATUS  Status;
+  UINTN       Cluster;
+  UINTN       CurSize;
+  UINTN       NewSize;
+  UINTN       LastCluster;
+  UINTN       NewCluster;
+  UINTN       ClusterCount;
+
+  //
+  // For FAT file system, the max file is 4GB.
+  //
+  if (NewSizeInBytes > 0x0FFFFFFFFL) {
+    return EFI_UNSUPPORTED;
+  }
+
+  Volume = OFile->Volume;
+  ASSERT_VOLUME_LOCKED (Volume);
+  //
+  // If the file is already large enough, do nothing
+  //
+  CurSize = FatSizeToClusters (Volume, OFile->FileSize);
+  NewSize = FatSizeToClusters (Volume, (UINTN) NewSizeInBytes);
+
+  if (CurSize < NewSize) {
+    //
+    // If we haven't found the files last cluster do it now
+    //
+    if ((OFile->FileCluster != 0) && (OFile->FileLastCluster == 0)) {
+      Cluster       = OFile->FileCluster;
+      ClusterCount  = 0;
+
+      while (!FAT_END_OF_FAT_CHAIN (Cluster)) {
+        if (Cluster < FAT_MIN_CLUSTER || Cluster > Volume->MaxCluster + 1) {
+
+          DEBUG (
+            (EFI_D_INIT | EFI_D_ERROR,
+            "FatGrowEof: cluster chain corrupt\n")
+            );
+          Status = EFI_VOLUME_CORRUPTED;
+          goto Done;
+        }
+
+        ClusterCount++;
+        OFile->FileLastCluster  = Cluster;
+        Cluster                 = FatGetFatEntry (Volume, Cluster);
+      }
+
+      if (ClusterCount != CurSize) {
+        DEBUG (
+          (EFI_D_INIT | EFI_D_ERROR,
+          "FatGrowEof: cluster chain size does not match file size\n")
+          );
+        Status = EFI_VOLUME_CORRUPTED;
+        goto Done;
+      }
+
+    }
+    //
+    // Loop until we've allocated enough space
+    //
+    LastCluster = OFile->FileLastCluster;
+
+    while (CurSize < NewSize) {
+      NewCluster = FatAllocateCluster (Volume);
+      if (FAT_END_OF_FAT_CHAIN (NewCluster)) {
+        if (LastCluster != FAT_CLUSTER_FREE) {
+          FatSetFatEntry (Volume, LastCluster, (UINTN) FAT_CLUSTER_LAST);
+          OFile->FileLastCluster = LastCluster;
+        }
+
+        Status = EFI_VOLUME_FULL;
+        goto Done;
+      }
+
+      if (NewCluster < FAT_MIN_CLUSTER || NewCluster > Volume->MaxCluster + 1) {
+        Status = EFI_VOLUME_CORRUPTED;
+        goto Done;
+      }
+
+      if (LastCluster != 0) {
+        FatSetFatEntry (Volume, LastCluster, NewCluster);
+      } else {
+        OFile->FileCluster        = NewCluster;
+        OFile->FileCurrentCluster = NewCluster;
+      }
+
+      LastCluster = NewCluster;
+      CurSize += 1;
+
+      //
+      // Terminate the cluster list
+      //
+      // Note that we must do this EVERY time we allocate a cluster, because
+      // FatAllocateCluster scans the FAT looking for a free cluster and
+      // "LastCluster" is no longer free!  Usually, FatAllocateCluster will
+      // start looking with the cluster after "LastCluster"; however, when
+      // there is only one free cluster left, it will find "LastCluster"
+      // a second time.  There are other, less predictable scenarios
+      // where this could happen, as well.
+      //
+      FatSetFatEntry (Volume, LastCluster, (UINTN) FAT_CLUSTER_LAST);
+      OFile->FileLastCluster = LastCluster;
+    }
+  }
+
+  OFile->FileSize = (UINTN) NewSizeInBytes;
+  OFile->Dirty    = TRUE;
+  return EFI_SUCCESS;
+
+Done:
+  FatShrinkEof (OFile);
+  return Status;
+}
+
+/**
+
+  Seek OFile to requested position, and calculate the number of
+  consecutive clusters from the position in the file
+
+  @param  OFile                 - The open file.
+  @param  Position              - The file's position which will be accessed.
+  @param  PosLimit              - The maximum length current reading/writing may access
+
+  @retval EFI_SUCCESS           - Set the info successfully.
+  @retval EFI_VOLUME_CORRUPTED  - Cluster chain corrupt.
+
+**/
+EFI_STATUS
+FatOFilePosition (
+  IN FAT_OFILE            *OFile,
+  IN UINTN                Position,
+  IN UINTN                PosLimit
+  )
+{
+  FAT_VOLUME  *Volume;
+  UINTN       ClusterSize;
+  UINTN       Cluster;
+  UINTN       StartPos;
+  UINTN       Run;
+
+  Volume      = OFile->Volume;
+  ClusterSize = Volume->ClusterSize;
+
+  ASSERT_VOLUME_LOCKED (Volume);
+
+  //
+  // If this is the fixed root dir, then compute its position
+  // from its fixed info in the fat bpb
+  //
+  if (OFile->IsFixedRootDir) {
+    OFile->PosDisk  = Volume->RootPos + Position;
+    Run             = OFile->FileSize - Position;
+  } else {
+    //
+    // Run the file's cluster chain to find the current position
+    // If possible, run from the current cluster rather than
+    // start from beginning
+    // Assumption: OFile->Position is always consistent with
+    // OFile->FileCurrentCluster.
+    // OFile->Position is not modified outside this function;
+    // OFile->FileCurrentCluster is modified outside this function
+    // to be the same as OFile->FileCluster
+    // when OFile->FileCluster is updated, so make a check of this
+    // and invalidate the original OFile->Position in this case
+    //
+    Cluster     = OFile->FileCurrentCluster;
+    StartPos    = OFile->Position;
+    if (Position < StartPos || OFile->FileCluster == Cluster) {
+      StartPos  = 0;
+      Cluster   = OFile->FileCluster;
+    }
+
+    while (StartPos + ClusterSize <= Position) {
+      StartPos += ClusterSize;
+      if (Cluster == FAT_CLUSTER_FREE || (Cluster >= FAT_CLUSTER_SPECIAL)) {
+        DEBUG ((EFI_D_INIT | EFI_D_ERROR, "FatOFilePosition:"" cluster chain corrupt\n"));
+        return EFI_VOLUME_CORRUPTED;
+      }
+
+      Cluster = FatGetFatEntry (Volume, Cluster);
+    }
+
+    if (Cluster < FAT_MIN_CLUSTER || Cluster > Volume->MaxCluster + 1) {
+      return EFI_VOLUME_CORRUPTED;
+    }
+
+    OFile->PosDisk            = Volume->FirstClusterPos +
+                                LShiftU64 (Cluster - FAT_MIN_CLUSTER, Volume->ClusterAlignment) +
+                                Position - StartPos;
+    OFile->FileCurrentCluster = Cluster;
+    OFile->Position           = StartPos;
+
+    //
+    // Compute the number of consecutive clusters in the file
+    //
+    Run = StartPos + ClusterSize - Position;
+    if (!FAT_END_OF_FAT_CHAIN (Cluster)) {
+      while ((FatGetFatEntry (Volume, Cluster) == Cluster + 1) && Run < PosLimit) {
+        Run     += ClusterSize;
+        Cluster += 1;
+      }
+    }
+  }
+
+  OFile->PosRem = Run;
+  return EFI_SUCCESS;
+}
+
+/**
+
+  Get the size of directory of the open file.
+
+  @param  Volume                - The File System Volume.
+  @param  Cluster               - The Starting cluster.
+
+  @return The physical size of the file starting at the input cluster, if there is error in the
+  cluster chain, the return value is 0.
+
+**/
+UINTN
+FatPhysicalDirSize (
+  IN FAT_VOLUME            *Volume,
+  IN UINTN                 Cluster
+  )
+{
+  UINTN Size;
+  ASSERT_VOLUME_LOCKED (Volume);
+  //
+  // Run the cluster chain for the OFile
+  //
+  Size = 0;
+  //
+  // N.B. ".." directories on some media do not contain a starting
+  // cluster.  In the case of "." or ".." we don't need the size anyway.
+  //
+  if (Cluster != 0) {
+    while (!FAT_END_OF_FAT_CHAIN (Cluster)) {
+      if (Cluster == FAT_CLUSTER_FREE || Cluster >= FAT_CLUSTER_SPECIAL) {
+        DEBUG (
+          (EFI_D_INIT | EFI_D_ERROR,
+          "FATDirSize: cluster chain corrupt\n")
+          );
+        return 0;
+      }
+
+      Size += Volume->ClusterSize;
+      Cluster = FatGetFatEntry (Volume, Cluster);
+    }
+  }
+
+  return Size;
+}
+
+/**
+
+  Get the physical size of a file on the disk.
+
+  @param  Volume                - The file system volume.
+  @param  RealSize              - The real size of a file.
+
+  @return The physical size of a file on the disk.
+
+**/
+UINT64
+FatPhysicalFileSize (
+  IN FAT_VOLUME            *Volume,
+  IN UINTN                 RealSize
+  )
+{
+  UINTN   ClusterSizeMask;
+  UINT64  PhysicalSize;
+  ClusterSizeMask = Volume->ClusterSize - 1;
+  PhysicalSize    = (RealSize + ClusterSizeMask) & (~((UINT64) ClusterSizeMask));
+  return PhysicalSize;
+}
+
+/**
+
+  Update the free cluster info of FatInfoSector of the volume.
+
+  @param  Volume                - FAT file system volume.
+
+**/
+VOID
+FatComputeFreeInfo (
+  IN FAT_VOLUME *Volume
+  )
+{
+  UINTN Index;
+
+  //
+  // If we don't have valid info, compute it now
+  //
+  if (!Volume->FreeInfoValid) {
+
+    Volume->FreeInfoValid                        = TRUE;
+    Volume->FatInfoSector.FreeInfo.ClusterCount  = 0;
+    for (Index = Volume->MaxCluster + 1; Index >= FAT_MIN_CLUSTER; Index--) {
+      if (Volume->DiskError) {
+        break;
+      }
+
+      if (FatGetFatEntry (Volume, Index) == FAT_CLUSTER_FREE) {
+        Volume->FatInfoSector.FreeInfo.ClusterCount += 1;
+        Volume->FatInfoSector.FreeInfo.NextCluster = (UINT32) Index;
+      }
+    }
+
+    Volume->FatInfoSector.Signature          = FAT_INFO_SIGNATURE;
+    Volume->FatInfoSector.InfoBeginSignature = FAT_INFO_BEGIN_SIGNATURE;
+    Volume->FatInfoSector.InfoEndSignature   = FAT_INFO_END_SIGNATURE;
+  }
+}
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Flush.c b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Flush.c
new file mode 100644
index 00000000..54a75bae
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Flush.c
@@ -0,0 +1,468 @@
+/** @file
+  Routines that check references and flush OFiles
+
+Copyright (c) 2005 - 2013, Intel Corporation. All rights reserved.<BR>
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+
+**/
+
+#include "Fat.h"
+
+/**
+
+  Flushes all data associated with the file handle.
+
+  @param  FHand                 - Handle to file to flush.
+  @param  Token                 - A pointer to the token associated with the transaction.
+
+  @retval EFI_SUCCESS           - Flushed the file successfully.
+  @retval EFI_WRITE_PROTECTED   - The volume is read only.
+  @retval EFI_ACCESS_DENIED     - The file is read only.
+  @return Others                - Flushing of the file failed.
+
+**/
+EFI_STATUS
+EFIAPI
+FatFlushEx (
+  IN EFI_FILE_PROTOCOL  *FHand,
+  IN EFI_FILE_IO_TOKEN  *Token
+  )
+{
+  FAT_IFILE   *IFile;
+  FAT_OFILE   *OFile;
+  FAT_VOLUME  *Volume;
+  EFI_STATUS  Status;
+  FAT_TASK    *Task;
+
+  IFile   = IFILE_FROM_FHAND (FHand);
+  OFile   = IFile->OFile;
+  Volume  = OFile->Volume;
+  Task    = NULL;
+
+  //
+  // If the file has a permanent error, return it
+  //
+  if (EFI_ERROR (OFile->Error)) {
+    return OFile->Error;
+  }
+
+  if (Volume->ReadOnly) {
+    return EFI_WRITE_PROTECTED;
+  }
+  //
+  // If read only, return error
+  //
+  if (IFile->ReadOnly) {
+    return EFI_ACCESS_DENIED;
+  }
+
+  if (Token == NULL) {
+    FatWaitNonblockingTask (IFile);
+  } else {
+    //
+    // Caller shouldn't call the non-blocking interfaces if the low layer doesn't support DiskIo2.
+    // But if it calls, the below check can avoid crash.
+    //
+    if (FHand->Revision < EFI_FILE_PROTOCOL_REVISION2) {
+      return EFI_UNSUPPORTED;
+    }
+    Task = FatCreateTask (IFile, Token);
+    if (Task == NULL) {
+      return EFI_OUT_OF_RESOURCES;
+    }
+  }
+
+  //
+  // Flush the OFile
+  //
+  FatAcquireLock ();
+  Status  = FatOFileFlush (OFile);
+  Status  = FatCleanupVolume (OFile->Volume, OFile, Status, Task);
+  FatReleaseLock ();
+
+  if (Token != NULL) {
+    if (!EFI_ERROR (Status)) {
+      Status = FatQueueTask (IFile, Task);
+    } else {
+      FatDestroyTask (Task);
+    }
+  }
+
+  return Status;
+}
+
+/**
+
+  Flushes all data associated with the file handle.
+
+  @param  FHand                 - Handle to file to flush.
+
+  @retval EFI_SUCCESS           - Flushed the file successfully.
+  @retval EFI_WRITE_PROTECTED   - The volume is read only.
+  @retval EFI_ACCESS_DENIED     - The file is read only.
+  @return Others                - Flushing of the file failed.
+
+**/
+EFI_STATUS
+EFIAPI
+FatFlush (
+  IN EFI_FILE_PROTOCOL  *FHand
+  )
+{
+  return FatFlushEx (FHand, NULL);
+}
+
+/**
+
+  Flushes & Closes the file handle.
+
+  @param  FHand                 - Handle to the file to delete.
+
+  @retval EFI_SUCCESS           - Closed the file successfully.
+
+**/
+EFI_STATUS
+EFIAPI
+FatClose (
+  IN EFI_FILE_PROTOCOL  *FHand
+  )
+{
+  FAT_IFILE   *IFile;
+  FAT_OFILE   *OFile;
+  FAT_VOLUME  *Volume;
+
+  IFile   = IFILE_FROM_FHAND (FHand);
+  OFile   = IFile->OFile;
+  Volume  = OFile->Volume;
+
+  //
+  // Lock the volume
+  //
+  FatAcquireLock ();
+
+  //
+  // Close the file instance handle
+  //
+  FatIFileClose (IFile);
+
+  //
+  // Done. Unlock the volume
+  //
+  FatCleanupVolume (Volume, OFile, EFI_SUCCESS, NULL);
+  FatReleaseLock ();
+
+  //
+  // Close always succeed
+  //
+  return EFI_SUCCESS;
+}
+
+/**
+
+  Close the open file instance.
+
+  @param  IFile                 - Open file instance.
+
+  @retval EFI_SUCCESS           - Closed the file successfully.
+
+**/
+EFI_STATUS
+FatIFileClose (
+  FAT_IFILE           *IFile
+  )
+{
+  FAT_OFILE   *OFile;
+  FAT_VOLUME  *Volume;
+
+  OFile   = IFile->OFile;
+  Volume  = OFile->Volume;
+
+  ASSERT_VOLUME_LOCKED (Volume);
+
+  FatWaitNonblockingTask (IFile);
+
+  //
+  // Remove the IFile struct
+  //
+  RemoveEntryList (&IFile->Link);
+
+  //
+  // Add the OFile to the check reference list
+  //
+  if (OFile->CheckLink.ForwardLink == NULL) {
+    InsertHeadList (&Volume->CheckRef, &OFile->CheckLink);
+  }
+  //
+  // Done. Free the open instance structure
+  //
+  FreePool (IFile);
+  return EFI_SUCCESS;
+}
+
+/**
+
+  Flush the data associated with an open file.
+  In this implementation, only last Mod/Access time is updated.
+
+  @param  OFile                 - The open file.
+
+  @retval EFI_SUCCESS           - The OFile is flushed successfully.
+  @return Others                - An error occurred when flushing this OFile.
+
+**/
+EFI_STATUS
+FatOFileFlush (
+  IN FAT_OFILE    *OFile
+  )
+{
+  EFI_STATUS    Status;
+  FAT_OFILE     *Parent;
+  FAT_DIRENT    *DirEnt;
+  FAT_DATE_TIME FatNow;
+
+  //
+  // Flush each entry up the tree while dirty
+  //
+  do {
+    //
+    // If the file has a permanent error, then don't write any
+    // of its data to the device (may be from different media)
+    //
+    if (EFI_ERROR (OFile->Error)) {
+      return OFile->Error;
+    }
+
+    Parent  = OFile->Parent;
+    DirEnt  = OFile->DirEnt;
+    if (OFile->Dirty) {
+      //
+      // Update the last modification time
+      //
+      FatGetCurrentFatTime (&FatNow);
+      CopyMem (&DirEnt->Entry.FileLastAccess, &FatNow.Date, sizeof (FAT_DATE));
+      if (!OFile->PreserveLastModification) {
+        FatGetCurrentFatTime (&DirEnt->Entry.FileModificationTime);
+      }
+
+      OFile->PreserveLastModification = FALSE;
+      if (OFile->Archive) {
+        DirEnt->Entry.Attributes |= FAT_ATTRIBUTE_ARCHIVE;
+        OFile->Archive = FALSE;
+      }
+      //
+      // Write the directory entry
+      //
+      if (Parent != NULL && !DirEnt->Invalid) {
+        //
+        // Write the OFile's directory entry
+        //
+        Status = FatStoreDirEnt (Parent, DirEnt);
+        if (EFI_ERROR (Status)) {
+          return Status;
+        }
+      }
+
+      OFile->Dirty = FALSE;
+    }
+    //
+    // Check the parent
+    //
+    OFile = Parent;
+  } while (OFile != NULL);
+  return EFI_SUCCESS;
+}
+
+/**
+
+  Check the references of the OFile.
+  If the OFile (that is checked) is no longer
+  referenced, then it is freed.
+
+  @param  OFile                 - The OFile to be checked.
+
+  @retval TRUE                  - The OFile is not referenced and freed.
+  @retval FALSE                 - The OFile is kept.
+
+**/
+BOOLEAN
+FatCheckOFileRef (
+  IN FAT_OFILE   *OFile
+  )
+{
+  //
+  // If the OFile is on the check ref list, remove it
+  //
+  if (OFile->CheckLink.ForwardLink != NULL) {
+    RemoveEntryList (&OFile->CheckLink);
+    OFile->CheckLink.ForwardLink = NULL;
+  }
+
+  FatOFileFlush (OFile);
+  //
+  // Are there any references to this OFile?
+  //
+  if (!IsListEmpty (&OFile->Opens) || !IsListEmpty (&OFile->ChildHead)) {
+    //
+    // The OFile cannot be freed
+    //
+    return FALSE;
+  }
+  //
+  // Free the Ofile
+  //
+  FatCloseDirEnt (OFile->DirEnt);
+  return TRUE;
+}
+
+/**
+
+  Check the references of all open files on the volume.
+  Any open file (that is checked) that is no longer
+  referenced, is freed - and its parent open file
+  is then referenced checked.
+
+  @param  Volume                - The volume to check the pending open file list.
+
+**/
+STATIC
+VOID
+FatCheckVolumeRef (
+  IN FAT_VOLUME   *Volume
+  )
+{
+  FAT_OFILE *OFile;
+  FAT_OFILE *Parent;
+
+  //
+  // Check all files on the pending check list
+  //
+  while (!IsListEmpty (&Volume->CheckRef)) {
+    //
+    // Start with the first file listed
+    //
+    Parent = OFILE_FROM_CHECKLINK (Volume->CheckRef.ForwardLink);
+    //
+    // Go up the tree cleaning up any un-referenced OFiles
+    //
+    while (Parent != NULL) {
+      OFile   = Parent;
+      Parent  = OFile->Parent;
+      if (!FatCheckOFileRef (OFile)) {
+        break;
+      }
+    }
+  }
+}
+
+/**
+
+  Set error status for a specific OFile, reference checking the volume.
+  If volume is already marked as invalid, and all resources are freed
+  after reference checking, the file system protocol is uninstalled and
+  the volume structure is freed.
+
+  @param  Volume                - the Volume that is to be reference checked and unlocked.
+  @param  OFile                 - the OFile whose permanent error code is to be set.
+  @param  EfiStatus             - error code to be set.
+  @param  Task                    point to task instance.
+
+  @retval EFI_SUCCESS           - Clean up the volume successfully.
+  @return Others                - Cleaning up of the volume is failed.
+
+**/
+EFI_STATUS
+FatCleanupVolume (
+  IN FAT_VOLUME       *Volume,
+  IN FAT_OFILE        *OFile,
+  IN EFI_STATUS       EfiStatus,
+  IN FAT_TASK         *Task
+  )
+{
+  EFI_STATUS  Status;
+  //
+  // Flag the OFile
+  //
+  if (OFile != NULL) {
+    FatSetVolumeError (OFile, EfiStatus);
+  }
+  //
+  // Clean up any dangling OFiles that don't have IFiles
+  // we don't check return status here because we want the
+  // volume be cleaned up even the volume is invalid.
+  //
+  FatCheckVolumeRef (Volume);
+  if (Volume->Valid) {
+    //
+    // Update the free hint info. Volume->FreeInfoPos != 0
+    // indicates this a FAT32 volume
+    //
+    if (Volume->FreeInfoValid && Volume->FatDirty && Volume->FreeInfoPos) {
+      Status = FatDiskIo (Volume, WriteDisk, Volume->FreeInfoPos, sizeof (FAT_INFO_SECTOR), &Volume->FatInfoSector, Task);
+      if (EFI_ERROR (Status)) {
+        return Status;
+      }
+    }
+    //
+    // Update that the volume is not dirty
+    //
+    if (Volume->FatDirty && Volume->FatType != Fat12) {
+      Volume->FatDirty  = FALSE;
+      Status            = FatAccessVolumeDirty (Volume, WriteFat, &Volume->NotDirtyValue);
+      if (EFI_ERROR (Status)) {
+        return Status;
+      }
+    }
+    //
+    // Flush all dirty cache entries to disk
+    //
+    Status = FatVolumeFlushCache (Volume, Task);
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+  }
+  //
+  // If the volume is cleared , remove it.
+  // The only time volume be invalidated is in DriverBindingStop.
+  //
+  if (Volume->Root == NULL && !Volume->Valid) {
+    //
+    // Free the volume structure
+    //
+    FatFreeVolume (Volume);
+  }
+
+  return EfiStatus;
+}
+
+/**
+
+  Set the OFile and its child OFile with the error Status
+
+  @param  OFile                 - The OFile whose permanent error code is to be set.
+  @param  Status                - Error code to be set.
+
+**/
+VOID
+FatSetVolumeError (
+  IN FAT_OFILE            *OFile,
+  IN EFI_STATUS           Status
+  )
+{
+  LIST_ENTRY      *Link;
+  FAT_OFILE       *ChildOFile;
+
+  //
+  // If this OFile doesn't already have an error, set one
+  //
+  if (!EFI_ERROR (OFile->Error)) {
+    OFile->Error = Status;
+  }
+  //
+  // Set the error on each child OFile
+  //
+  for (Link = OFile->ChildHead.ForwardLink; Link != &OFile->ChildHead; Link = Link->ForwardLink) {
+    ChildOFile = OFILE_FROM_CHILDLINK (Link);
+    FatSetVolumeError (ChildOFile, Status);
+  }
+}
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Hash.c b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Hash.c
new file mode 100644
index 00000000..90e33b17
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Hash.c
@@ -0,0 +1,166 @@
+/** @file
+  Hash table operations.
+
+Copyright (c) 2005 - 2015, Intel Corporation. All rights reserved.<BR>
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "Fat.h"
+
+/**
+
+  Get hash value for long name.
+
+  @param  LongNameString        - The long name string to be hashed.
+
+  @return HashValue.
+
+**/
+STATIC
+UINT32
+FatHashLongName (
+  IN CHAR16   *LongNameString
+  )
+{
+  UINT32  HashValue;
+  CHAR16  UpCasedLongFileName[EFI_PATH_STRING_LENGTH];
+  StrnCpyS (
+    UpCasedLongFileName,
+    ARRAY_SIZE (UpCasedLongFileName),
+    LongNameString,
+    ARRAY_SIZE (UpCasedLongFileName) - 1
+    );
+  FatStrUpr (UpCasedLongFileName);
+  gBS->CalculateCrc32 (UpCasedLongFileName, StrSize (UpCasedLongFileName), &HashValue);
+  return (HashValue & HASH_TABLE_MASK);
+}
+
+/**
+
+  Get hash value for short name.
+
+  @param  ShortNameString       - The short name string to be hashed.
+
+  @return HashValue
+
+**/
+STATIC
+UINT32
+FatHashShortName (
+  IN CHAR8   *ShortNameString
+  )
+{
+  UINT32  HashValue;
+  gBS->CalculateCrc32 (ShortNameString, FAT_NAME_LEN, &HashValue);
+  return (HashValue & HASH_TABLE_MASK);
+}
+
+/**
+
+  Search the long name hash table for the directory entry.
+
+  @param  ODir                  - The directory to be searched.
+  @param  LongNameString        - The long name string to search.
+
+  @return The previous long name hash node of the directory entry.
+
+**/
+FAT_DIRENT **
+FatLongNameHashSearch (
+  IN FAT_ODIR       *ODir,
+  IN CHAR16         *LongNameString
+  )
+{
+  FAT_DIRENT  **PreviousHashNode;
+  for (PreviousHashNode   = &ODir->LongNameHashTable[FatHashLongName (LongNameString)];
+       *PreviousHashNode != NULL;
+       PreviousHashNode   = &(*PreviousHashNode)->LongNameForwardLink
+      ) {
+    if (FatStriCmp (LongNameString, (*PreviousHashNode)->FileString) == 0) {
+      break;
+    }
+  }
+
+  return PreviousHashNode;
+}
+
+/**
+
+  Search the short name hash table for the directory entry.
+
+  @param  ODir                  - The directory to be searched.
+  @param  ShortNameString       - The short name string to search.
+
+  @return The previous short name hash node of the directory entry.
+
+**/
+FAT_DIRENT **
+FatShortNameHashSearch (
+  IN FAT_ODIR      *ODir,
+  IN CHAR8         *ShortNameString
+  )
+{
+  FAT_DIRENT  **PreviousHashNode;
+  for (PreviousHashNode   = &ODir->ShortNameHashTable[FatHashShortName (ShortNameString)];
+       *PreviousHashNode != NULL;
+       PreviousHashNode   = &(*PreviousHashNode)->ShortNameForwardLink
+      ) {
+    if (CompareMem (ShortNameString, (*PreviousHashNode)->Entry.FileName, FAT_NAME_LEN) == 0) {
+      break;
+    }
+  }
+
+  return PreviousHashNode;
+}
+
+/**
+
+  Insert directory entry to hash table.
+
+  @param  ODir                  - The parent directory.
+  @param  DirEnt                - The directory entry node.
+
+**/
+VOID
+FatInsertToHashTable (
+  IN FAT_ODIR     *ODir,
+  IN FAT_DIRENT   *DirEnt
+  )
+{
+  FAT_DIRENT  **HashTable;
+  UINT32      HashTableIndex;
+
+  //
+  // Insert hash table index for short name
+  //
+  HashTableIndex                = FatHashShortName (DirEnt->Entry.FileName);
+  HashTable                     = ODir->ShortNameHashTable;
+  DirEnt->ShortNameForwardLink  = HashTable[HashTableIndex];
+  HashTable[HashTableIndex]     = DirEnt;
+  //
+  // Insert hash table index for long name
+  //
+  HashTableIndex                = FatHashLongName (DirEnt->FileString);
+  HashTable                     = ODir->LongNameHashTable;
+  DirEnt->LongNameForwardLink   = HashTable[HashTableIndex];
+  HashTable[HashTableIndex]     = DirEnt;
+}
+
+/**
+
+  Delete directory entry from hash table.
+
+  @param  ODir                  - The parent directory.
+  @param  DirEnt                - The directory entry node.
+
+**/
+VOID
+FatDeleteFromHashTable (
+  IN FAT_ODIR     *ODir,
+  IN FAT_DIRENT   *DirEnt
+  )
+{
+  *FatShortNameHashSearch (ODir, DirEnt->Entry.FileName) = DirEnt->ShortNameForwardLink;
+  *FatLongNameHashSearch (ODir, DirEnt->FileString)      = DirEnt->LongNameForwardLink;
+}
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Info.c b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Info.c
new file mode 100644
index 00000000..879c2678
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Info.c
@@ -0,0 +1,595 @@
+/** @file
+  Routines dealing with setting/getting file/volume info
+
+Copyright (c) 2005 - 2015, Intel Corporation. All rights reserved.<BR>
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+
+
+**/
+
+#include "Fat.h"
+
+/**
+
+  Get the volume's info into Buffer.
+
+  @param  Volume                - FAT file system volume.
+  @param  BufferSize            - Size of Buffer.
+  @param  Buffer                - Buffer containing volume info.
+
+  @retval EFI_SUCCESS           - Get the volume info successfully.
+  @retval EFI_BUFFER_TOO_SMALL  - The buffer is too small.
+
+**/
+EFI_STATUS
+FatGetVolumeInfo (
+  IN FAT_VOLUME       *Volume,
+  IN OUT UINTN        *BufferSize,
+  OUT VOID            *Buffer
+  );
+
+/**
+
+  Set the volume's info.
+
+  @param  Volume                - FAT file system volume.
+  @param  BufferSize            - Size of Buffer.
+  @param  Buffer                - Buffer containing the new volume info.
+
+  @retval EFI_SUCCESS           - Set the volume info successfully.
+  @retval EFI_BAD_BUFFER_SIZE   - The buffer size is error.
+  @retval EFI_WRITE_PROTECTED   - The volume is read only.
+  @return other                 - An error occurred when operation the disk.
+
+**/
+EFI_STATUS
+FatSetVolumeInfo (
+  IN FAT_VOLUME       *Volume,
+  IN UINTN            BufferSize,
+  IN VOID            *Buffer
+  );
+
+/**
+
+  Set or Get the some types info of the file into Buffer.
+
+  @param  IsSet      - TRUE:The access is set, else is get
+  @param  FHand      - The handle of file
+  @param  Type       - The type of the info
+  @param  BufferSize - Size of Buffer
+  @param  Buffer     - Buffer containing volume info
+
+  @retval EFI_SUCCESS       - Get the info successfully
+  @retval EFI_DEVICE_ERROR  - Can not find the OFile for the file
+
+**/
+EFI_STATUS
+FatSetOrGetInfo (
+  IN BOOLEAN              IsSet,
+  IN EFI_FILE_PROTOCOL    *FHand,
+  IN EFI_GUID             *Type,
+  IN OUT UINTN            *BufferSize,
+  IN OUT VOID             *Buffer
+  );
+
+/**
+
+  Get the open file's info into Buffer.
+
+  @param  OFile                 - The open file.
+  @param  BufferSize            - Size of Buffer.
+  @param  Buffer                - Buffer containing file info.
+
+  @retval EFI_SUCCESS           - Get the file info successfully.
+  @retval EFI_BUFFER_TOO_SMALL  - The buffer is too small.
+
+**/
+EFI_STATUS
+FatGetFileInfo (
+  IN FAT_OFILE        *OFile,
+  IN OUT UINTN        *BufferSize,
+  OUT VOID            *Buffer
+  )
+{
+  return FatGetDirEntInfo (OFile->Volume, OFile->DirEnt, BufferSize, Buffer);
+}
+
+/**
+
+  Get the volume's info into Buffer.
+
+  @param  Volume                - FAT file system volume.
+  @param  BufferSize            - Size of Buffer.
+  @param  Buffer                - Buffer containing volume info.
+
+  @retval EFI_SUCCESS           - Get the volume info successfully.
+  @retval EFI_BUFFER_TOO_SMALL  - The buffer is too small.
+
+**/
+EFI_STATUS
+FatGetVolumeInfo (
+  IN     FAT_VOLUME     *Volume,
+  IN OUT UINTN          *BufferSize,
+     OUT VOID           *Buffer
+  )
+{
+  UINTN                 Size;
+  UINTN                 NameSize;
+  UINTN                 ResultSize;
+  CHAR16                Name[FAT_NAME_LEN + 1];
+  EFI_STATUS            Status;
+  EFI_FILE_SYSTEM_INFO  *Info;
+  UINT8                 ClusterAlignment;
+
+  Size              = SIZE_OF_EFI_FILE_SYSTEM_INFO;
+  Status            = FatGetVolumeEntry (Volume, Name);
+  NameSize          = StrSize (Name);
+  ResultSize        = Size + NameSize;
+  ClusterAlignment  = Volume->ClusterAlignment;
+
+  //
+  // If we don't have valid info, compute it now
+  //
+  FatComputeFreeInfo (Volume);
+
+  Status = EFI_BUFFER_TOO_SMALL;
+  if (*BufferSize >= ResultSize) {
+    Status  = EFI_SUCCESS;
+
+    Info    = Buffer;
+    ZeroMem (Info, SIZE_OF_EFI_FILE_SYSTEM_INFO);
+
+    Info->Size        = ResultSize;
+    Info->ReadOnly    = Volume->ReadOnly;
+    Info->BlockSize   = (UINT32) Volume->ClusterSize;
+    Info->VolumeSize  = LShiftU64 (Volume->MaxCluster, ClusterAlignment);
+    Info->FreeSpace   = LShiftU64 (
+                          Volume->FatInfoSector.FreeInfo.ClusterCount,
+                          ClusterAlignment
+                          );
+    CopyMem ((CHAR8 *) Buffer + Size, Name, NameSize);
+  }
+
+  *BufferSize = ResultSize;
+  return Status;
+}
+
+/**
+
+  Get the volume's label info into Buffer.
+
+  @param  Volume                - FAT file system volume.
+  @param  BufferSize            - Size of Buffer.
+  @param  Buffer                - Buffer containing volume's label info.
+
+  @retval EFI_SUCCESS           - Get the volume's label info successfully.
+  @retval EFI_BUFFER_TOO_SMALL  - The buffer is too small.
+
+**/
+EFI_STATUS
+FatGetVolumeLabelInfo (
+  IN FAT_VOLUME       *Volume,
+  IN OUT UINTN        *BufferSize,
+  OUT VOID            *Buffer
+  )
+{
+  UINTN                             Size;
+  UINTN                             NameSize;
+  UINTN                             ResultSize;
+  CHAR16                            Name[FAT_NAME_LEN + 1];
+  EFI_STATUS                        Status;
+
+  Size        = SIZE_OF_EFI_FILE_SYSTEM_VOLUME_LABEL;
+  Status      = FatGetVolumeEntry (Volume, Name);
+  NameSize    = StrSize (Name);
+  ResultSize  = Size + NameSize;
+
+  Status      = EFI_BUFFER_TOO_SMALL;
+  if (*BufferSize >= ResultSize) {
+    Status  = EFI_SUCCESS;
+    CopyMem ((CHAR8 *) Buffer + Size, Name, NameSize);
+  }
+
+  *BufferSize = ResultSize;
+  return Status;
+}
+
+/**
+
+  Set the volume's info.
+
+  @param  Volume                - FAT file system volume.
+  @param  BufferSize            - Size of Buffer.
+  @param  Buffer                - Buffer containing the new volume info.
+
+  @retval EFI_SUCCESS           - Set the volume info successfully.
+  @retval EFI_BAD_BUFFER_SIZE   - The buffer size is error.
+  @retval EFI_WRITE_PROTECTED   - The volume is read only.
+  @return other                 - An error occurred when operation the disk.
+
+**/
+EFI_STATUS
+FatSetVolumeInfo (
+  IN FAT_VOLUME       *Volume,
+  IN UINTN            BufferSize,
+  IN VOID             *Buffer
+  )
+{
+  EFI_FILE_SYSTEM_INFO  *Info;
+
+  Info = (EFI_FILE_SYSTEM_INFO *) Buffer;
+
+  if (BufferSize < SIZE_OF_EFI_FILE_SYSTEM_INFO + 2 || Info->Size > BufferSize) {
+    return EFI_BAD_BUFFER_SIZE;
+  }
+
+  return FatSetVolumeEntry (Volume, Info->VolumeLabel);
+}
+
+/**
+
+  Set the volume's label info.
+
+  @param  Volume                - FAT file system volume.
+  @param  BufferSize            - Size of Buffer.
+  @param  Buffer                - Buffer containing the new volume label info.
+
+  @retval EFI_SUCCESS           - Set the volume label info successfully.
+  @retval EFI_WRITE_PROTECTED   - The disk is write protected.
+  @retval EFI_BAD_BUFFER_SIZE   - The buffer size is error.
+  @return other                 - An error occurred when operation the disk.
+
+**/
+EFI_STATUS
+FatSetVolumeLabelInfo (
+  IN FAT_VOLUME       *Volume,
+  IN UINTN            BufferSize,
+  IN VOID             *Buffer
+  )
+{
+  EFI_FILE_SYSTEM_VOLUME_LABEL *Info;
+
+  Info = (EFI_FILE_SYSTEM_VOLUME_LABEL *) Buffer;
+
+  if (BufferSize < SIZE_OF_EFI_FILE_SYSTEM_VOLUME_LABEL + 2) {
+    return EFI_BAD_BUFFER_SIZE;
+  }
+
+  return FatSetVolumeEntry (Volume, Info->VolumeLabel);
+}
+
+/**
+
+  Set the file info.
+
+  @param  Volume                - FAT file system volume.
+  @param  IFile                 - The instance of the open file.
+  @param  OFile                 - The open file.
+  @param  BufferSize            - Size of Buffer.
+  @param  Buffer                - Buffer containing the new file info.
+
+  @retval EFI_SUCCESS           - Set the file info successfully.
+  @retval EFI_ACCESS_DENIED     - It is the root directory
+                          or the directory attribute bit can not change
+                          or try to change a directory size
+                          or something else.
+  @retval EFI_UNSUPPORTED       - The new file size is larger than 4GB.
+  @retval EFI_WRITE_PROTECTED   - The disk is write protected.
+  @retval EFI_BAD_BUFFER_SIZE   - The buffer size is error.
+  @retval EFI_INVALID_PARAMETER - The time info or attributes info is error.
+  @retval EFI_OUT_OF_RESOURCES  - Can not allocate new memory.
+  @retval EFI_VOLUME_CORRUPTED  - The volume is corrupted.
+  @return other                 - An error occurred when operation the disk.
+
+**/
+EFI_STATUS
+FatSetFileInfo (
+  IN FAT_VOLUME       *Volume,
+  IN FAT_IFILE        *IFile,
+  IN FAT_OFILE        *OFile,
+  IN UINTN            BufferSize,
+  IN VOID             *Buffer
+  )
+{
+  EFI_STATUS    Status;
+  EFI_FILE_INFO *NewInfo;
+  FAT_OFILE     *DotOFile;
+  FAT_OFILE     *Parent;
+  CHAR16        NewFileName[EFI_PATH_STRING_LENGTH];
+  EFI_TIME      ZeroTime;
+  FAT_DIRENT    *DirEnt;
+  FAT_DIRENT    *TempDirEnt;
+  UINT8         NewAttribute;
+  BOOLEAN       ReadOnly;
+
+  ZeroMem (&ZeroTime, sizeof (EFI_TIME));
+  Parent  = OFile->Parent;
+  DirEnt  = OFile->DirEnt;
+  //
+  // If this is the root directory, we can't make any updates
+  //
+  if (Parent == NULL) {
+    return EFI_ACCESS_DENIED;
+  }
+  //
+  // Make sure there's a valid input buffer
+  //
+  NewInfo = Buffer;
+  if (BufferSize < SIZE_OF_EFI_FILE_INFO + 2 || NewInfo->Size > BufferSize) {
+    return EFI_BAD_BUFFER_SIZE;
+  }
+
+  ReadOnly = (BOOLEAN)(IFile->ReadOnly || (DirEnt->Entry.Attributes & EFI_FILE_READ_ONLY));
+  //
+  // if a zero time is specified, then the original time is preserved
+  //
+  if (CompareMem (&ZeroTime, &NewInfo->CreateTime, sizeof (EFI_TIME)) != 0) {
+    if (!FatIsValidTime (&NewInfo->CreateTime)) {
+      return EFI_INVALID_PARAMETER;
+    }
+
+    if (!ReadOnly) {
+      FatEfiTimeToFatTime (&NewInfo->CreateTime, &DirEnt->Entry.FileCreateTime);
+    }
+  }
+
+  if (CompareMem (&ZeroTime, &NewInfo->ModificationTime, sizeof (EFI_TIME)) != 0) {
+    if (!FatIsValidTime (&NewInfo->ModificationTime)) {
+      return EFI_INVALID_PARAMETER;
+    }
+
+    if (!ReadOnly) {
+      FatEfiTimeToFatTime (&NewInfo->ModificationTime, &DirEnt->Entry.FileModificationTime);
+    }
+
+    OFile->PreserveLastModification = TRUE;
+  }
+
+  if (NewInfo->Attribute & (~EFI_FILE_VALID_ATTR)) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  NewAttribute = (UINT8) NewInfo->Attribute;
+  //
+  // Can not change the directory attribute bit
+  //
+  if ((NewAttribute ^ DirEnt->Entry.Attributes) & EFI_FILE_DIRECTORY) {
+    return EFI_ACCESS_DENIED;
+  }
+  //
+  // Set the current attributes even if the IFile->ReadOnly is TRUE
+  //
+  DirEnt->Entry.Attributes = (UINT8) ((DirEnt->Entry.Attributes &~EFI_FILE_VALID_ATTR) | NewAttribute);
+  //
+  // Open the filename and see if it refers to an existing file
+  //
+  Status = FatLocateOFile (&Parent, NewInfo->FileName, DirEnt->Entry.Attributes, NewFileName);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  if (*NewFileName != 0) {
+    //
+    // File was not found.  We do not allow rename of the current directory if
+    // there are open files below the current directory
+    //
+    if (!IsListEmpty (&OFile->ChildHead) || Parent == OFile) {
+      return EFI_ACCESS_DENIED;
+    }
+
+    if (ReadOnly) {
+      return EFI_ACCESS_DENIED;
+    }
+
+    Status = FatRemoveDirEnt (OFile->Parent, DirEnt);
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+    //
+    // Create new dirent
+    //
+    Status = FatCreateDirEnt (Parent, NewFileName, DirEnt->Entry.Attributes, &TempDirEnt);
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+
+    FatCloneDirEnt (TempDirEnt, DirEnt);
+    FatFreeDirEnt (DirEnt);
+    DirEnt        = TempDirEnt;
+    DirEnt->OFile = OFile;
+    OFile->DirEnt = DirEnt;
+    OFile->Parent = Parent;
+    RemoveEntryList (&OFile->ChildLink);
+    InsertHeadList (&Parent->ChildHead, &OFile->ChildLink);
+    //
+    // If this is a directory, synchronize its dot directory entry
+    //
+    if (OFile->ODir != NULL) {
+      //
+      // Synchronize its dot entry
+      //
+      FatResetODirCursor (OFile);
+      ASSERT (OFile->Parent != NULL);
+      for (DotOFile = OFile; DotOFile != OFile->Parent->Parent; DotOFile = DotOFile->Parent) {
+        Status = FatGetNextDirEnt (OFile, &DirEnt);
+        if (EFI_ERROR (Status) || DirEnt == NULL || !FatIsDotDirEnt (DirEnt)) {
+          return EFI_VOLUME_CORRUPTED;
+        }
+
+        FatCloneDirEnt (DirEnt, DotOFile->DirEnt);
+        Status = FatStoreDirEnt (OFile, DirEnt);
+        if (EFI_ERROR (Status)) {
+          return Status;
+        }
+      }
+    }
+    //
+    // If the file is renamed, we should append the ARCHIVE attribute
+    //
+    OFile->Archive = TRUE;
+  } else if (Parent != OFile) {
+    //
+    // filename is to a different filename that already exists
+    //
+    return EFI_ACCESS_DENIED;
+  }
+  //
+  // If the file size has changed, apply it
+  //
+  if (NewInfo->FileSize != OFile->FileSize) {
+    if (OFile->ODir != NULL || ReadOnly) {
+      //
+      // If this is a directory or the file is read only, we can't change the file size
+      //
+      return EFI_ACCESS_DENIED;
+    }
+
+    if (NewInfo->FileSize > OFile->FileSize) {
+      Status = FatExpandOFile (OFile, NewInfo->FileSize);
+    } else {
+      Status = FatTruncateOFile (OFile, (UINTN) NewInfo->FileSize);
+    }
+
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+
+    FatUpdateDirEntClusterSizeInfo (OFile);
+  }
+
+  OFile->Dirty = TRUE;
+  return FatOFileFlush (OFile);
+}
+
+/**
+
+  Set or Get the some types info of the file into Buffer.
+
+  @param  IsSet      - TRUE:The access is set, else is get
+  @param  FHand      - The handle of file
+  @param  Type       - The type of the info
+  @param  BufferSize - Size of Buffer
+  @param  Buffer     - Buffer containing volume info
+
+  @retval EFI_SUCCESS       - Get the info successfully
+  @retval EFI_DEVICE_ERROR  - Can not find the OFile for the file
+
+**/
+EFI_STATUS
+FatSetOrGetInfo (
+  IN     BOOLEAN            IsSet,
+  IN     EFI_FILE_PROTOCOL  *FHand,
+  IN     EFI_GUID           *Type,
+  IN OUT UINTN              *BufferSize,
+  IN OUT VOID               *Buffer
+  )
+{
+  FAT_IFILE   *IFile;
+  FAT_OFILE   *OFile;
+  FAT_VOLUME  *Volume;
+  EFI_STATUS  Status;
+
+  IFile   = IFILE_FROM_FHAND (FHand);
+  OFile   = IFile->OFile;
+  Volume  = OFile->Volume;
+
+  Status  = OFile->Error;
+  if (Status == EFI_NOT_FOUND) {
+    return EFI_DEVICE_ERROR;
+  }
+
+  FatWaitNonblockingTask (IFile);
+
+  FatAcquireLock ();
+
+  //
+  // Verify the file handle isn't in an error state
+  //
+  if (!EFI_ERROR (Status)) {
+    //
+    // Get the proper information based on the request
+    //
+    Status = EFI_UNSUPPORTED;
+    if (IsSet) {
+      if (CompareGuid (Type, &gEfiFileInfoGuid)) {
+        Status = Volume->ReadOnly ? EFI_WRITE_PROTECTED : FatSetFileInfo (Volume, IFile, OFile, *BufferSize, Buffer);
+      }
+
+      if (CompareGuid (Type, &gEfiFileSystemInfoGuid)) {
+        Status = Volume->ReadOnly ? EFI_WRITE_PROTECTED : FatSetVolumeInfo (Volume, *BufferSize, Buffer);
+      }
+
+      if (CompareGuid (Type, &gEfiFileSystemVolumeLabelInfoIdGuid)) {
+        Status = Volume->ReadOnly ? EFI_WRITE_PROTECTED : FatSetVolumeLabelInfo (Volume, *BufferSize, Buffer);
+      }
+    } else {
+      if (CompareGuid (Type, &gEfiFileInfoGuid)) {
+        Status = FatGetFileInfo (OFile, BufferSize, Buffer);
+      }
+
+      if (CompareGuid (Type, &gEfiFileSystemInfoGuid)) {
+        Status = FatGetVolumeInfo (Volume, BufferSize, Buffer);
+      }
+
+      if (CompareGuid (Type, &gEfiFileSystemVolumeLabelInfoIdGuid)) {
+        Status = FatGetVolumeLabelInfo (Volume, BufferSize, Buffer);
+      }
+    }
+  }
+
+  Status = FatCleanupVolume (Volume, NULL, Status, NULL);
+
+  FatReleaseLock ();
+  return Status;
+}
+
+/**
+
+  Get the some types info of the file into Buffer.
+
+  @param  FHand                 - The handle of file.
+  @param  Type                  - The type of the info.
+  @param  BufferSize            - Size of Buffer.
+  @param  Buffer                - Buffer containing volume info.
+
+  @retval EFI_SUCCESS           - Get the info successfully.
+  @retval EFI_DEVICE_ERROR      - Can not find the OFile for the file.
+
+**/
+EFI_STATUS
+EFIAPI
+FatGetInfo (
+  IN     EFI_FILE_PROTOCOL   *FHand,
+  IN     EFI_GUID            *Type,
+  IN OUT UINTN               *BufferSize,
+     OUT VOID                *Buffer
+  )
+{
+  return FatSetOrGetInfo (FALSE, FHand, Type, BufferSize, Buffer);
+}
+
+/**
+
+  Set the some types info of the file into Buffer.
+
+  @param  FHand                 - The handle of file.
+  @param  Type                  - The type of the info.
+  @param  BufferSize            - Size of Buffer
+  @param  Buffer                - Buffer containing volume info.
+
+  @retval EFI_SUCCESS           - Set the info successfully.
+  @retval EFI_DEVICE_ERROR      - Can not find the OFile for the file.
+
+**/
+EFI_STATUS
+EFIAPI
+FatSetInfo (
+  IN EFI_FILE_PROTOCOL  *FHand,
+  IN EFI_GUID           *Type,
+  IN UINTN              BufferSize,
+  IN VOID               *Buffer
+  )
+{
+  return FatSetOrGetInfo (TRUE, FHand, Type, &BufferSize, Buffer);
+}
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Init.c b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Init.c
new file mode 100644
index 00000000..b888e436
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Init.c
@@ -0,0 +1,387 @@
+/** @file
+  Initialization routines.
+
+Copyright (c) 2005 - 2013, Intel Corporation. All rights reserved.<BR>
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "Fat.h"
+
+/**
+
+  Allocates volume structure, detects FAT file system, installs protocol,
+  and initialize cache.
+
+  @param  Handle                - The handle of parent device.
+  @param  DiskIo                - The DiskIo of parent device.
+  @param  DiskIo2               - The DiskIo2 of parent device.
+  @param  BlockIo               - The BlockIo of parent device.
+
+  @retval EFI_SUCCESS           - Allocate a new volume successfully.
+  @retval EFI_OUT_OF_RESOURCES  - Can not allocate the memory.
+  @return Others                - Allocating a new volume failed.
+
+**/
+EFI_STATUS
+FatAllocateVolume (
+  IN  EFI_HANDLE                Handle,
+  IN  EFI_DISK_IO_PROTOCOL      *DiskIo,
+  IN  EFI_DISK_IO2_PROTOCOL     *DiskIo2,
+  IN  EFI_BLOCK_IO_PROTOCOL     *BlockIo
+  )
+{
+  EFI_STATUS  Status;
+  FAT_VOLUME  *Volume;
+
+  //
+  // Allocate a volume structure
+  //
+  Volume = AllocateZeroPool (sizeof (FAT_VOLUME));
+  if (Volume == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  //
+  // Initialize the structure
+  //
+  Volume->Signature                   = FAT_VOLUME_SIGNATURE;
+  Volume->Handle                      = Handle;
+  Volume->DiskIo                      = DiskIo;
+  Volume->DiskIo2                     = DiskIo2;
+  Volume->BlockIo                     = BlockIo;
+  Volume->MediaId                     = BlockIo->Media->MediaId;
+  Volume->ReadOnly                    = BlockIo->Media->ReadOnly;
+  Volume->VolumeInterface.Revision    = EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION;
+  Volume->VolumeInterface.OpenVolume  = FatOpenVolume;
+  InitializeListHead (&Volume->CheckRef);
+  InitializeListHead (&Volume->DirCacheList);
+  //
+  // Initialize Root Directory entry
+  //
+  Volume->RootDirEnt.FileString       = Volume->RootFileString;
+  Volume->RootDirEnt.Entry.Attributes = FAT_ATTRIBUTE_DIRECTORY;
+  //
+  // Check to see if there's a file system on the volume
+  //
+  Status = FatOpenDevice (Volume);
+  if (EFI_ERROR (Status)) {
+    goto Done;
+  }
+  //
+  // Initialize cache
+  //
+  Status = FatInitializeDiskCache (Volume);
+  if (EFI_ERROR (Status)) {
+    goto Done;
+  }
+  //
+  // Install our protocol interfaces on the device's handle
+  //
+  Status = gBS->InstallMultipleProtocolInterfaces (
+                  &Volume->Handle,
+                  &gEfiSimpleFileSystemProtocolGuid,
+                  &Volume->VolumeInterface,
+                  NULL
+                  );
+  if (EFI_ERROR (Status)) {
+    goto Done;
+  }
+  //
+  // Volume installed
+  //
+  DEBUG ((EFI_D_INIT, "Installed Fat filesystem on %p\n", Handle));
+  Volume->Valid = TRUE;
+
+Done:
+  if (EFI_ERROR (Status)) {
+    FatFreeVolume (Volume);
+  }
+
+  return Status;
+}
+
+/**
+
+  Called by FatDriverBindingStop(), Abandon the volume.
+
+  @param  Volume                - The volume to be abandoned.
+
+  @retval EFI_SUCCESS           - Abandoned the volume successfully.
+  @return Others                - Can not uninstall the protocol interfaces.
+
+**/
+EFI_STATUS
+FatAbandonVolume (
+  IN FAT_VOLUME *Volume
+  )
+{
+  EFI_STATUS  Status;
+  BOOLEAN     LockedByMe;
+
+  //
+  // Uninstall the protocol interface.
+  //
+  if (Volume->Handle != NULL) {
+    Status = gBS->UninstallMultipleProtocolInterfaces (
+                    Volume->Handle,
+                    &gEfiSimpleFileSystemProtocolGuid,
+                    &Volume->VolumeInterface,
+                    NULL
+                    );
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+  }
+
+  LockedByMe = FALSE;
+
+  //
+  // Acquire the lock.
+  // If the caller has already acquired the lock (which
+  // means we are in the process of some Fat operation),
+  // we can not acquire again.
+  //
+  Status = FatAcquireLockOrFail ();
+  if (!EFI_ERROR (Status)) {
+    LockedByMe = TRUE;
+  }
+  //
+  // The volume is still being used. Hence, set error flag for all OFiles still in
+  // use. In two cases, we could get here. One is EFI_MEDIA_CHANGED, the other is
+  // EFI_NO_MEDIA.
+  //
+  if (Volume->Root != NULL) {
+    FatSetVolumeError (
+      Volume->Root,
+      Volume->BlockIo->Media->MediaPresent ? EFI_MEDIA_CHANGED : EFI_NO_MEDIA
+      );
+  }
+
+  Volume->Valid = FALSE;
+
+  //
+  // Release the lock.
+  // If locked by me, this means DriverBindingStop is NOT
+  // called within an on-going Fat operation, so we should
+  // take responsibility to cleanup and free the volume.
+  // Otherwise, the DriverBindingStop is called within an on-going
+  // Fat operation, we shouldn't check reference, so just let outer
+  // FatCleanupVolume do the task.
+  //
+  if (LockedByMe) {
+    FatCleanupVolume (Volume, NULL, EFI_SUCCESS, NULL);
+    FatReleaseLock ();
+  }
+
+  return EFI_SUCCESS;
+}
+
+/**
+
+  Detects FAT file system on Disk and set relevant fields of Volume.
+
+  @param Volume                - The volume structure.
+
+  @retval EFI_SUCCESS           - The Fat File System is detected successfully
+  @retval EFI_UNSUPPORTED       - The volume is not FAT file system.
+  @retval EFI_VOLUME_CORRUPTED  - The volume is corrupted.
+
+**/
+EFI_STATUS
+FatOpenDevice (
+  IN OUT FAT_VOLUME           *Volume
+  )
+{
+  EFI_STATUS            Status;
+  UINT32                BlockSize;
+  UINT32                DirtyMask;
+  EFI_DISK_IO_PROTOCOL  *DiskIo;
+  FAT_BOOT_SECTOR       FatBs;
+  FAT_VOLUME_TYPE       FatType;
+  UINTN                 RootDirSectors;
+  UINTN                 FatLba;
+  UINTN                 RootLba;
+  UINTN                 FirstClusterLba;
+  UINTN                 Sectors;
+  UINTN                 SectorsPerFat;
+  UINT8                 SectorsPerClusterAlignment;
+  UINT8                 BlockAlignment;
+
+  //
+  // Read the FAT_BOOT_SECTOR BPB info
+  // This is the only part of FAT code that uses parent DiskIo,
+  // Others use FatDiskIo which utilizes a Cache.
+  //
+  DiskIo  = Volume->DiskIo;
+  Status  = DiskIo->ReadDisk (DiskIo, Volume->MediaId, 0, sizeof (FatBs), &FatBs);
+
+  if (EFI_ERROR (Status)) {
+    DEBUG ((EFI_D_INIT, "FatOpenDevice: read of part_lba failed %r\n", Status));
+    return Status;
+  }
+
+  FatType = FatUndefined;
+
+  //
+  // Use LargeSectors if Sectors is 0
+  //
+  Sectors = FatBs.FatBsb.Sectors;
+  if (Sectors == 0) {
+    Sectors = FatBs.FatBsb.LargeSectors;
+  }
+
+  SectorsPerFat = FatBs.FatBsb.SectorsPerFat;
+  if (SectorsPerFat == 0) {
+    SectorsPerFat = FatBs.FatBse.Fat32Bse.LargeSectorsPerFat;
+    FatType       = Fat32;
+  }
+  //
+  // Is boot sector a fat sector?
+  // (Note that so far we only know if the sector is FAT32 or not, we don't
+  // know if the sector is Fat16 or Fat12 until later when we can compute
+  // the volume size)
+  //
+  if (FatBs.FatBsb.ReservedSectors == 0 || FatBs.FatBsb.NumFats == 0 || Sectors == 0) {
+    return EFI_UNSUPPORTED;
+  }
+
+  if ((FatBs.FatBsb.SectorSize & (FatBs.FatBsb.SectorSize - 1)) != 0) {
+    return EFI_UNSUPPORTED;
+  }
+
+  BlockAlignment = (UINT8) HighBitSet32 (FatBs.FatBsb.SectorSize);
+  if (BlockAlignment > MAX_BLOCK_ALIGNMENT || BlockAlignment < MIN_BLOCK_ALIGNMENT) {
+    return EFI_UNSUPPORTED;
+  }
+
+  if ((FatBs.FatBsb.SectorsPerCluster & (FatBs.FatBsb.SectorsPerCluster - 1)) != 0) {
+    return EFI_UNSUPPORTED;
+  }
+
+  SectorsPerClusterAlignment = (UINT8) HighBitSet32 (FatBs.FatBsb.SectorsPerCluster);
+  if (SectorsPerClusterAlignment > MAX_SECTORS_PER_CLUSTER_ALIGNMENT) {
+    return EFI_UNSUPPORTED;
+  }
+
+  if (FatBs.FatBsb.Media <= 0xf7 &&
+      FatBs.FatBsb.Media != 0xf0 &&
+      FatBs.FatBsb.Media != 0x00 &&
+      FatBs.FatBsb.Media != 0x01
+      ) {
+    return EFI_UNSUPPORTED;
+  }
+  //
+  // Initialize fields the volume information for this FatType
+  //
+  if (FatType != Fat32) {
+    if (FatBs.FatBsb.RootEntries == 0) {
+      return EFI_UNSUPPORTED;
+    }
+    //
+    // Unpack fat12, fat16 info
+    //
+    Volume->RootEntries = FatBs.FatBsb.RootEntries;
+  } else {
+    //
+    // If this is fat32, refuse to mount mirror-disabled volumes
+    //
+    if ((SectorsPerFat == 0 || FatBs.FatBse.Fat32Bse.FsVersion != 0) || (FatBs.FatBse.Fat32Bse.ExtendedFlags & 0x80)) {
+      return EFI_UNSUPPORTED;
+    }
+    //
+    // Unpack fat32 info
+    //
+    Volume->RootCluster = FatBs.FatBse.Fat32Bse.RootDirFirstCluster;
+  }
+
+  Volume->NumFats           = FatBs.FatBsb.NumFats;
+  //
+  // Compute some fat locations
+  //
+  BlockSize                 = FatBs.FatBsb.SectorSize;
+  RootDirSectors            = ((Volume->RootEntries * sizeof (FAT_DIRECTORY_ENTRY)) + (BlockSize - 1)) / BlockSize;
+
+  FatLba                    = FatBs.FatBsb.ReservedSectors;
+  RootLba                   = FatBs.FatBsb.NumFats * SectorsPerFat + FatLba;
+  FirstClusterLba           = RootLba + RootDirSectors;
+
+  Volume->FatPos            = FatLba * BlockSize;
+  Volume->FatSize           = SectorsPerFat * BlockSize;
+
+  Volume->VolumeSize        = LShiftU64 (Sectors, BlockAlignment);
+  Volume->RootPos           = LShiftU64 (RootLba, BlockAlignment);
+  Volume->FirstClusterPos   = LShiftU64 (FirstClusterLba, BlockAlignment);
+  Volume->MaxCluster        = (Sectors - FirstClusterLba) >> SectorsPerClusterAlignment;
+  Volume->ClusterAlignment  = (UINT8)(BlockAlignment + SectorsPerClusterAlignment);
+  Volume->ClusterSize       = (UINTN)1 << (Volume->ClusterAlignment);
+
+  //
+  // If this is not a fat32, determine if it's a fat16 or fat12
+  //
+  if (FatType != Fat32) {
+    if (Volume->MaxCluster >= FAT_MAX_FAT16_CLUSTER) {
+      return EFI_VOLUME_CORRUPTED;
+    }
+
+    FatType = Volume->MaxCluster < FAT_MAX_FAT12_CLUSTER ? Fat12 : Fat16;
+    //
+    // fat12 & fat16 fat-entries are 2 bytes
+    //
+    Volume->FatEntrySize = sizeof (UINT16);
+    DirtyMask            = FAT16_DIRTY_MASK;
+  } else {
+    if (Volume->MaxCluster < FAT_MAX_FAT16_CLUSTER) {
+      return EFI_VOLUME_CORRUPTED;
+    }
+    //
+    // fat32 fat-entries are 4 bytes
+    //
+    Volume->FatEntrySize = sizeof (UINT32);
+    DirtyMask            = FAT32_DIRTY_MASK;
+  }
+  //
+  // Get the DirtyValue and NotDirtyValue
+  // We should keep the initial value as the NotDirtyValue
+  // in case the volume is dirty already
+  //
+  if (FatType != Fat12) {
+    Status = FatAccessVolumeDirty (Volume, ReadDisk, &Volume->NotDirtyValue);
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+
+    Volume->DirtyValue = Volume->NotDirtyValue & DirtyMask;
+  }
+  //
+  // If present, read the fat hint info
+  //
+  if (FatType == Fat32) {
+    Volume->FreeInfoPos = FatBs.FatBse.Fat32Bse.FsInfoSector * BlockSize;
+    if (FatBs.FatBse.Fat32Bse.FsInfoSector != 0) {
+      FatDiskIo (Volume, ReadDisk, Volume->FreeInfoPos, sizeof (FAT_INFO_SECTOR), &Volume->FatInfoSector, NULL);
+      if (Volume->FatInfoSector.Signature == FAT_INFO_SIGNATURE &&
+          Volume->FatInfoSector.InfoBeginSignature == FAT_INFO_BEGIN_SIGNATURE &&
+          Volume->FatInfoSector.InfoEndSignature == FAT_INFO_END_SIGNATURE &&
+          Volume->FatInfoSector.FreeInfo.ClusterCount <= Volume->MaxCluster
+          ) {
+        Volume->FreeInfoValid = TRUE;
+      }
+    }
+  }
+  //
+  // Just make up a FreeInfo.NextCluster for use by allocate cluster
+  //
+  if (FAT_MIN_CLUSTER > Volume->FatInfoSector.FreeInfo.NextCluster ||
+     Volume->FatInfoSector.FreeInfo.NextCluster > Volume->MaxCluster + 1
+     ) {
+    Volume->FatInfoSector.FreeInfo.NextCluster = FAT_MIN_CLUSTER;
+  }
+  //
+  // We are now defining FAT Type
+  //
+  Volume->FatType = FatType;
+  ASSERT (FatType != FatUndefined);
+
+  return EFI_SUCCESS;
+}
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Misc.c b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Misc.c
new file mode 100644
index 00000000..d13bd276
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Misc.c
@@ -0,0 +1,612 @@
+/** @file
+  Miscellaneous functions.
+
+Copyright (c) 2005 - 2018, Intel Corporation. All rights reserved.<BR>
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+
+**/
+
+#include "Fat.h"
+UINT8  mMonthDays[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+
+/**
+
+  Create the task
+
+  @param  IFile                 - The instance of the open file.
+  @param  Token                 - A pointer to the token associated with the transaction.
+
+  @return FAT_TASK *            - Return the task instance.
+
+**/
+FAT_TASK *
+FatCreateTask (
+  FAT_IFILE           *IFile,
+  EFI_FILE_IO_TOKEN   *Token
+  )
+{
+  FAT_TASK            *Task;
+
+  Task = AllocateZeroPool (sizeof (*Task));
+  if (Task != NULL) {
+    Task->Signature   = FAT_TASK_SIGNATURE;
+    Task->IFile       = IFile;
+    Task->FileIoToken = Token;
+    InitializeListHead (&Task->Subtasks);
+    InitializeListHead (&Task->Link);
+  }
+  return Task;
+}
+
+/**
+
+  Destroy the task.
+
+  @param  Task                  - The task to be destroyed.
+
+**/
+VOID
+FatDestroyTask (
+  FAT_TASK            *Task
+  )
+{
+  LIST_ENTRY          *Link;
+  FAT_SUBTASK         *Subtask;
+
+  Link = GetFirstNode (&Task->Subtasks);
+  while (!IsNull (&Task->Subtasks, Link)) {
+    Subtask = CR (Link, FAT_SUBTASK, Link, FAT_SUBTASK_SIGNATURE);
+    Link = FatDestroySubtask (Subtask);
+  }
+  FreePool (Task);
+}
+
+/**
+
+  Wait all non-blocking requests complete.
+
+  @param  IFile                 - The instance of the open file.
+
+**/
+VOID
+FatWaitNonblockingTask (
+  FAT_IFILE           *IFile
+  )
+{
+  BOOLEAN             TaskQueueEmpty;
+
+  do {
+    EfiAcquireLock (&FatTaskLock);
+    TaskQueueEmpty = IsListEmpty (&IFile->Tasks);
+    EfiReleaseLock (&FatTaskLock);
+  } while (!TaskQueueEmpty);
+}
+
+/**
+
+  Remove the subtask from subtask list.
+
+  @param  Subtask               - The subtask to be removed.
+
+  @return LIST_ENTRY *          - The next node in the list.
+
+**/
+LIST_ENTRY *
+FatDestroySubtask (
+  FAT_SUBTASK         *Subtask
+  )
+{
+  LIST_ENTRY          *Link;
+
+  gBS->CloseEvent (Subtask->DiskIo2Token.Event);
+
+  Link = RemoveEntryList (&Subtask->Link);
+  FreePool (Subtask);
+
+  return Link;
+}
+
+/**
+
+  Execute the task.
+
+  @param  IFile                 - The instance of the open file.
+  @param  Task                  - The task to be executed.
+
+  @retval EFI_SUCCESS           - The task was executed successfully.
+  @return other                 - An error occurred when executing the task.
+
+**/
+EFI_STATUS
+FatQueueTask (
+  IN FAT_IFILE        *IFile,
+  IN FAT_TASK         *Task
+  )
+{
+  EFI_STATUS          Status;
+  LIST_ENTRY          *Link;
+  LIST_ENTRY          *NextLink;
+  FAT_SUBTASK         *Subtask;
+
+  //
+  // Sometimes the Task doesn't contain any subtasks, signal the event directly.
+  //
+  if (IsListEmpty (&Task->Subtasks)) {
+    Task->FileIoToken->Status = EFI_SUCCESS;
+    gBS->SignalEvent (Task->FileIoToken->Event);
+    FreePool (Task);
+    return EFI_SUCCESS;
+  }
+
+  EfiAcquireLock (&FatTaskLock);
+  InsertTailList (&IFile->Tasks, &Task->Link);
+  EfiReleaseLock (&FatTaskLock);
+
+  Status = EFI_SUCCESS;
+  //
+  // Use NextLink to store the next link of the list, because Link might be remove from the
+  // doubly-linked list and get freed in the end of current loop.
+  //
+  // Also, list operation APIs like IsNull() and GetNextNode() are avoided during the loop, since
+  // they may check the validity of doubly-linked lists by traversing them. These APIs cannot
+  // handle list elements being removed during the traverse.
+  //
+  for ( Link = GetFirstNode (&Task->Subtasks), NextLink = GetNextNode (&Task->Subtasks, Link)
+      ; Link != &Task->Subtasks
+      ; Link = NextLink, NextLink = Link->ForwardLink
+      ) {
+    Subtask = CR (Link, FAT_SUBTASK, Link, FAT_SUBTASK_SIGNATURE);
+    if (Subtask->Write) {
+
+      Status = IFile->OFile->Volume->DiskIo2->WriteDiskEx (
+                                                IFile->OFile->Volume->DiskIo2,
+                                                IFile->OFile->Volume->MediaId,
+                                                Subtask->Offset,
+                                                &Subtask->DiskIo2Token,
+                                                Subtask->BufferSize,
+                                                Subtask->Buffer
+                                                );
+    } else {
+      Status = IFile->OFile->Volume->DiskIo2->ReadDiskEx (
+                                                IFile->OFile->Volume->DiskIo2,
+                                                IFile->OFile->Volume->MediaId,
+                                                Subtask->Offset,
+                                                &Subtask->DiskIo2Token,
+                                                Subtask->BufferSize,
+                                                Subtask->Buffer
+                                                );
+    }
+    if (EFI_ERROR (Status)) {
+      break;
+    }
+  }
+
+  if (EFI_ERROR (Status)) {
+    EfiAcquireLock (&FatTaskLock);
+    //
+    // Remove all the remaining subtasks when failure.
+    // We shouldn't remove all the tasks because the non-blocking requests have
+    // been submitted and cannot be canceled.
+    //
+    while (!IsNull (&Task->Subtasks, Link)) {
+      Subtask = CR (Link, FAT_SUBTASK, Link, FAT_SUBTASK_SIGNATURE);
+      Link = FatDestroySubtask (Subtask);
+    }
+
+    if (IsListEmpty (&Task->Subtasks)) {
+      RemoveEntryList (&Task->Link);
+      FreePool (Task);
+    } else {
+      //
+      // If one or more subtasks have been already submitted, set FileIoToken
+      // to NULL so that the callback won't signal the event.
+      //
+      Task->FileIoToken = NULL;
+    }
+
+    EfiReleaseLock (&FatTaskLock);
+  }
+
+  return Status;
+}
+
+/**
+
+  Set the volume as dirty or not.
+
+  @param  Volume                - FAT file system volume.
+  @param  IoMode                - The access mode.
+  @param  DirtyValue            - Set the volume as dirty or not.
+
+  @retval EFI_SUCCESS           - Set the new FAT entry value successfully.
+  @return other                 - An error occurred when operation the FAT entries.
+
+**/
+EFI_STATUS
+FatAccessVolumeDirty (
+  IN FAT_VOLUME       *Volume,
+  IN IO_MODE          IoMode,
+  IN VOID             *DirtyValue
+  )
+{
+  UINTN WriteCount;
+
+  WriteCount = Volume->FatEntrySize;
+  return FatDiskIo (Volume, IoMode, Volume->FatPos + WriteCount, WriteCount, DirtyValue, NULL);
+}
+
+/**
+  Invoke a notification event.
+
+  @param  Event                 Event whose notification function is being invoked.
+  @param  Context               The pointer to the notification function's context,
+                                which is implementation-dependent.
+
+**/
+VOID
+EFIAPI
+FatOnAccessComplete (
+  IN  EFI_EVENT                Event,
+  IN  VOID                     *Context
+  )
+{
+  EFI_STATUS             Status;
+  FAT_SUBTASK            *Subtask;
+  FAT_TASK               *Task;
+
+  //
+  // Avoid someone in future breaks the below assumption.
+  //
+  ASSERT (EfiGetCurrentTpl () == FatTaskLock.Tpl);
+
+  Subtask = (FAT_SUBTASK *) Context;
+  Task    = Subtask->Task;
+  Status  = Subtask->DiskIo2Token.TransactionStatus;
+
+  ASSERT (Task->Signature    == FAT_TASK_SIGNATURE);
+  ASSERT (Subtask->Signature == FAT_SUBTASK_SIGNATURE);
+
+  //
+  // Remove the task unconditionally
+  //
+  FatDestroySubtask (Subtask);
+
+  //
+  // Task->FileIoToken is NULL which means the task will be ignored (just recycle the subtask and task memory).
+  //
+  if (Task->FileIoToken != NULL) {
+    if (IsListEmpty (&Task->Subtasks) || EFI_ERROR (Status)) {
+      Task->FileIoToken->Status = Status;
+      gBS->SignalEvent (Task->FileIoToken->Event);
+      //
+      // Mark Task->FileIoToken to NULL so that the subtasks belonging to the task will be ignored.
+      //
+      Task->FileIoToken = NULL;
+    }
+  }
+
+  if (IsListEmpty (&Task->Subtasks)) {
+    RemoveEntryList (&Task->Link);
+    FreePool (Task);
+  }
+}
+
+/**
+
+  General disk access function.
+
+  @param  Volume                - FAT file system volume.
+  @param  IoMode                - The access mode (disk read/write or cache access).
+  @param  Offset                - The starting byte offset to read from.
+  @param  BufferSize            - Size of Buffer.
+  @param  Buffer                - Buffer containing read data.
+  @param  Task                    point to task instance.
+
+  @retval EFI_SUCCESS           - The operation is performed successfully.
+  @retval EFI_VOLUME_CORRUPTED  - The access is
+  @return Others                - The status of read/write the disk
+
+**/
+EFI_STATUS
+FatDiskIo (
+  IN     FAT_VOLUME       *Volume,
+  IN     IO_MODE          IoMode,
+  IN     UINT64           Offset,
+  IN     UINTN            BufferSize,
+  IN OUT VOID             *Buffer,
+  IN     FAT_TASK         *Task
+  )
+{
+  EFI_STATUS            Status;
+  EFI_DISK_IO_PROTOCOL  *DiskIo;
+  EFI_DISK_READ         IoFunction;
+  FAT_SUBTASK           *Subtask;
+
+  //
+  // Verify the IO is in devices range
+  //
+  Status = EFI_VOLUME_CORRUPTED;
+  if (Offset + BufferSize <= Volume->VolumeSize) {
+    if (CACHE_ENABLED (IoMode)) {
+      //
+      // Access cache
+      //
+      Status = FatAccessCache (Volume, CACHE_TYPE (IoMode), RAW_ACCESS (IoMode), Offset, BufferSize, Buffer, Task);
+    } else {
+      //
+      // Access disk directly
+      //
+      if (Task == NULL) {
+        //
+        // Blocking access
+        //
+        DiskIo      = Volume->DiskIo;
+        IoFunction  = (IoMode == ReadDisk) ? DiskIo->ReadDisk : DiskIo->WriteDisk;
+        Status      = IoFunction (DiskIo, Volume->MediaId, Offset, BufferSize, Buffer);
+      } else {
+        //
+        // Non-blocking access
+        //
+        Subtask = AllocateZeroPool (sizeof (*Subtask));
+        if (Subtask == NULL) {
+          Status        = EFI_OUT_OF_RESOURCES;
+        } else {
+          Subtask->Signature  = FAT_SUBTASK_SIGNATURE;
+          Subtask->Task       = Task;
+          Subtask->Write      = (BOOLEAN) (IoMode == WriteDisk);
+          Subtask->Offset     = Offset;
+          Subtask->Buffer     = Buffer;
+          Subtask->BufferSize = BufferSize;
+          Status = gBS->CreateEvent (
+                          EVT_NOTIFY_SIGNAL,
+                          TPL_NOTIFY,
+                          FatOnAccessComplete,
+                          Subtask,
+                          &Subtask->DiskIo2Token.Event
+                          );
+          if (!EFI_ERROR (Status)) {
+            InsertTailList (&Task->Subtasks, &Subtask->Link);
+          } else {
+            FreePool (Subtask);
+          }
+        }
+      }
+    }
+  }
+
+  if (EFI_ERROR (Status)) {
+    Volume->DiskError = TRUE;
+    DEBUG ((EFI_D_ERROR, "FatDiskIo: error %r\n", Status));
+  }
+
+  return Status;
+}
+
+/**
+
+  Lock the volume.
+
+**/
+VOID
+FatAcquireLock (
+  VOID
+  )
+{
+  EfiAcquireLock (&FatFsLock);
+}
+
+/**
+
+  Lock the volume.
+  If the lock is already in the acquired state, then EFI_ACCESS_DENIED is returned.
+  Otherwise, EFI_SUCCESS is returned.
+
+  @retval EFI_SUCCESS           - The volume is locked.
+  @retval EFI_ACCESS_DENIED     - The volume could not be locked because it is already locked.
+
+**/
+EFI_STATUS
+FatAcquireLockOrFail (
+  VOID
+  )
+{
+  return EfiAcquireLockOrFail (&FatFsLock);
+}
+
+/**
+
+  Unlock the volume.
+
+**/
+VOID
+FatReleaseLock (
+  VOID
+  )
+{
+  EfiReleaseLock (&FatFsLock);
+}
+
+/**
+
+  Free directory entry.
+
+  @param  DirEnt                - The directory entry to be freed.
+
+**/
+VOID
+FatFreeDirEnt (
+  IN FAT_DIRENT       *DirEnt
+  )
+{
+  if (DirEnt->FileString != NULL) {
+    FreePool (DirEnt->FileString);
+  }
+
+  FreePool (DirEnt);
+}
+
+/**
+
+  Free volume structure (including the contents of directory cache and disk cache).
+
+  @param  Volume                - The volume structure to be freed.
+
+**/
+VOID
+FatFreeVolume (
+  IN FAT_VOLUME       *Volume
+  )
+{
+  //
+  // Free disk cache
+  //
+  if (Volume->CacheBuffer != NULL) {
+    FreePool (Volume->CacheBuffer);
+  }
+  //
+  // Free directory cache
+  //
+  FatCleanupODirCache (Volume);
+  FreePool (Volume);
+}
+
+/**
+
+  Translate EFI time to FAT time.
+
+  @param  ETime                 - The time of EFI_TIME.
+  @param  FTime                 - The time of FAT_DATE_TIME.
+
+**/
+VOID
+FatEfiTimeToFatTime (
+  IN  EFI_TIME        *ETime,
+  OUT FAT_DATE_TIME   *FTime
+  )
+{
+  //
+  // ignores timezone info in source ETime
+  //
+  if (ETime->Year > 1980) {
+    FTime->Date.Year = (UINT16) (ETime->Year - 1980);
+  }
+
+  if (ETime->Year >= 1980 + FAT_MAX_YEAR_FROM_1980) {
+    FTime->Date.Year = FAT_MAX_YEAR_FROM_1980;
+  }
+
+  FTime->Date.Month         = ETime->Month;
+  FTime->Date.Day           = ETime->Day;
+  FTime->Time.Hour          = ETime->Hour;
+  FTime->Time.Minute        = ETime->Minute;
+  FTime->Time.DoubleSecond  = (UINT16) (ETime->Second / 2);
+}
+
+/**
+
+  Translate Fat time to EFI time.
+
+  @param  FTime                 - The time of FAT_DATE_TIME.
+  @param  ETime                 - The time of EFI_TIME..
+
+**/
+VOID
+FatFatTimeToEfiTime (
+  IN  FAT_DATE_TIME     *FTime,
+  OUT EFI_TIME          *ETime
+  )
+{
+  ETime->Year       = (UINT16) (FTime->Date.Year + 1980);
+  ETime->Month      = (UINT8) FTime->Date.Month;
+  ETime->Day        = (UINT8) FTime->Date.Day;
+  ETime->Hour       = (UINT8) FTime->Time.Hour;
+  ETime->Minute     = (UINT8) FTime->Time.Minute;
+  ETime->Second     = (UINT8) (FTime->Time.DoubleSecond * 2);
+  ETime->Nanosecond = 0;
+  ETime->TimeZone   = EFI_UNSPECIFIED_TIMEZONE;
+  ETime->Daylight   = 0;
+}
+
+/**
+
+  Get Current FAT time.
+
+  @param  FatNow                - Current FAT time.
+
+**/
+VOID
+FatGetCurrentFatTime (
+  OUT FAT_DATE_TIME   *FatNow
+  )
+{
+  EFI_STATUS Status;
+  EFI_TIME   Now;
+
+  Status = gRT->GetTime (&Now, NULL);
+  if (!EFI_ERROR (Status)) {
+    FatEfiTimeToFatTime (&Now, FatNow);
+  } else {
+    ZeroMem (&Now, sizeof (EFI_TIME));
+    Now.Year = 1980;
+    Now.Month = 1;
+    Now.Day = 1;
+    FatEfiTimeToFatTime (&Now, FatNow);
+  }
+}
+
+/**
+
+  Check whether a time is valid.
+
+  @param  Time                  - The time of EFI_TIME.
+
+  @retval TRUE                  - The time is valid.
+  @retval FALSE                 - The time is not valid.
+
+**/
+BOOLEAN
+FatIsValidTime (
+  IN EFI_TIME         *Time
+  )
+{
+  UINTN         Day;
+  BOOLEAN       ValidTime;
+
+  ValidTime = TRUE;
+
+  //
+  // Check the fields for range problems
+  // Fat can only support from 1980
+  //
+  if (Time->Year < 1980 ||
+      Time->Month < 1 ||
+      Time->Month > 12 ||
+      Time->Day < 1 ||
+      Time->Day > 31 ||
+      Time->Hour > 23 ||
+      Time->Minute > 59 ||
+      Time->Second > 59 ||
+      Time->Nanosecond > 999999999
+      ) {
+
+    ValidTime = FALSE;
+
+  } else {
+    //
+    // Perform a more specific check of the day of the month
+    //
+    Day = mMonthDays[Time->Month - 1];
+    if (Time->Month == 2 && IS_LEAP_YEAR (Time->Year)) {
+      Day += 1;
+      //
+      // 1 extra day this month
+      //
+    }
+    if (Time->Day > Day) {
+      ValidTime = FALSE;
+    }
+  }
+
+  return ValidTime;
+}
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Open.c b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Open.c
new file mode 100644
index 00000000..ac00e899
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/Open.c
@@ -0,0 +1,320 @@
+/** @file
+  Routines dealing with file open.
+
+Copyright (c) 2005 - 2018, Intel Corporation. All rights reserved.<BR>
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "Fat.h"
+
+/**
+
+  Create an Open instance for the existing OFile.
+  The IFile of the newly opened file is passed out.
+
+  @param  OFile                 - The file that serves as a starting reference point.
+  @param  PtrIFile              - The newly generated IFile instance.
+
+  @retval EFI_OUT_OF_RESOURCES  - Can not allocate the memory for the IFile
+  @retval EFI_SUCCESS           - Create the new IFile for the OFile successfully
+
+**/
+EFI_STATUS
+FatAllocateIFile (
+  IN FAT_OFILE    *OFile,
+  OUT FAT_IFILE   **PtrIFile
+  )
+{
+  FAT_IFILE *IFile;
+
+  ASSERT_VOLUME_LOCKED (OFile->Volume);
+
+  //
+  // Allocate a new open instance
+  //
+  IFile = AllocateZeroPool (sizeof (FAT_IFILE));
+  if (IFile == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  IFile->Signature = FAT_IFILE_SIGNATURE;
+
+  CopyMem (&(IFile->Handle), &FatFileInterface, sizeof (EFI_FILE_PROTOCOL));
+
+  //
+  // Report the correct revision number based on the DiskIo2 availability
+  //
+  if (OFile->Volume->DiskIo2 != NULL) {
+    IFile->Handle.Revision = EFI_FILE_PROTOCOL_REVISION2;
+  } else {
+    IFile->Handle.Revision = EFI_FILE_PROTOCOL_REVISION;
+  }
+
+  IFile->OFile = OFile;
+  InsertTailList (&OFile->Opens, &IFile->Link);
+  InitializeListHead (&IFile->Tasks);
+
+  *PtrIFile = IFile;
+  return EFI_SUCCESS;
+}
+
+/**
+
+  Open a file for a file name relative to an existing OFile.
+  The IFile of the newly opened file is passed out.
+
+  @param  OFile                 - The file that serves as a starting reference point.
+  @param  NewIFile              - The newly generated IFile instance.
+  @param  FileName              - The file name relative to the OFile.
+  @param  OpenMode              - Open mode.
+  @param  Attributes            - Attributes to set if the file is created.
+
+
+  @retval EFI_SUCCESS           - Open the file successfully.
+  @retval EFI_INVALID_PARAMETER - The open mode is conflict with the attributes
+                          or the file name is not valid.
+  @retval EFI_NOT_FOUND         - Conflicts between dir intention and attribute.
+  @retval EFI_WRITE_PROTECTED   - Can't open for write if the volume is read only.
+  @retval EFI_ACCESS_DENIED     - If the file's attribute is read only, and the
+                          open is for read-write fail it.
+  @retval EFI_OUT_OF_RESOURCES  - Can not allocate the memory.
+
+**/
+EFI_STATUS
+FatOFileOpen (
+  IN  FAT_OFILE            *OFile,
+  OUT FAT_IFILE            **NewIFile,
+  IN  CHAR16               *FileName,
+  IN  UINT64               OpenMode,
+  IN  UINT8                Attributes
+  )
+{
+  FAT_VOLUME  *Volume;
+  EFI_STATUS  Status;
+  CHAR16      NewFileName[EFI_PATH_STRING_LENGTH];
+  FAT_DIRENT  *DirEnt;
+  UINT8       FileAttributes;
+  BOOLEAN     WriteMode;
+
+  DirEnt = NULL;
+  Volume = OFile->Volume;
+  ASSERT_VOLUME_LOCKED (Volume);
+  WriteMode = (BOOLEAN) (OpenMode & EFI_FILE_MODE_WRITE);
+  if (Volume->ReadOnly && WriteMode) {
+    return EFI_WRITE_PROTECTED;
+  }
+  //
+  // Verify the source file handle isn't in an error state
+  //
+  Status = OFile->Error;
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  //
+  // Get new OFile for the file
+  //
+  Status = FatLocateOFile (&OFile, FileName, Attributes, NewFileName);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  if (*NewFileName != 0) {
+    //
+    // If there's a remaining part of the name, then we had
+    // better be creating the file in the directory
+    //
+    if ((OpenMode & EFI_FILE_MODE_CREATE) == 0) {
+      return EFI_NOT_FOUND;
+    }
+
+    Status = FatCreateDirEnt (OFile, NewFileName, Attributes, &DirEnt);
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+
+    ASSERT (DirEnt != NULL);
+    Status = FatOpenDirEnt (OFile, DirEnt);
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+
+    OFile = DirEnt->OFile;
+    if (OFile->ODir != NULL) {
+      //
+      // If we just created a directory, we need to create "." and ".."
+      //
+      Status = FatCreateDotDirEnts (OFile);
+      if (EFI_ERROR (Status)) {
+        return Status;
+      }
+    }
+  }
+  //
+  // If the file's attribute is read only, and the open is for
+  // read-write, then the access is denied.
+  //
+  FileAttributes = OFile->DirEnt->Entry.Attributes;
+  if ((FileAttributes & EFI_FILE_READ_ONLY) != 0 && (FileAttributes & FAT_ATTRIBUTE_DIRECTORY) == 0 && WriteMode) {
+    return EFI_ACCESS_DENIED;
+  }
+  //
+  // Create an open instance of the OFile
+  //
+  Status = FatAllocateIFile (OFile, NewIFile);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  (*NewIFile)->ReadOnly = (BOOLEAN)!WriteMode;
+
+  DEBUG ((EFI_D_INFO, "FSOpen: Open '%S' %r\n", FileName, Status));
+  return FatOFileFlush (OFile);
+}
+
+/**
+
+  Implements OpenEx() of Simple File System Protocol.
+
+  @param  FHand                 - File handle of the file serves as a starting reference point.
+  @param  NewHandle             - Handle of the file that is newly opened.
+  @param  FileName              - File name relative to FHand.
+  @param  OpenMode              - Open mode.
+  @param  Attributes            - Attributes to set if the file is created.
+  @param  Token                 - A pointer to the token associated with the transaction.:
+
+  @retval EFI_INVALID_PARAMETER - The FileName is NULL or the file string is empty.
+                          The OpenMode is not supported.
+                          The Attributes is not the valid attributes.
+  @retval EFI_OUT_OF_RESOURCES  - Can not allocate the memory for file string.
+  @retval EFI_SUCCESS           - Open the file successfully.
+  @return Others                - The status of open file.
+
+**/
+EFI_STATUS
+EFIAPI
+FatOpenEx (
+  IN  EFI_FILE_PROTOCOL       *FHand,
+  OUT EFI_FILE_PROTOCOL       **NewHandle,
+  IN  CHAR16                  *FileName,
+  IN  UINT64                  OpenMode,
+  IN  UINT64                  Attributes,
+  IN OUT EFI_FILE_IO_TOKEN    *Token
+  )
+{
+  FAT_IFILE   *IFile;
+  FAT_IFILE   *NewIFile;
+  FAT_OFILE   *OFile;
+  EFI_STATUS  Status;
+  FAT_TASK    *Task;
+
+  //
+  // Perform some parameter checking
+  //
+  if (FileName == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+  //
+  // Check for a valid mode
+  //
+  switch (OpenMode) {
+  case EFI_FILE_MODE_READ:
+  case EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE:
+  case EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE:
+    break;
+
+  default:
+    return EFI_INVALID_PARAMETER;
+  }
+
+  //
+  // Check for valid Attributes for file creation case.
+  //
+  if (((OpenMode & EFI_FILE_MODE_CREATE) != 0) && (Attributes & (EFI_FILE_READ_ONLY | (~EFI_FILE_VALID_ATTR))) != 0) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  IFile = IFILE_FROM_FHAND (FHand);
+  OFile = IFile->OFile;
+  Task  = NULL;
+
+  if (Token == NULL) {
+    FatWaitNonblockingTask (IFile);
+  } else {
+    //
+    // Caller shouldn't call the non-blocking interfaces if the low layer doesn't support DiskIo2.
+    // But if it calls, the below check can avoid crash.
+    //
+    if (FHand->Revision < EFI_FILE_PROTOCOL_REVISION2) {
+      return EFI_UNSUPPORTED;
+    }
+    Task = FatCreateTask (IFile, Token);
+    if (Task == NULL) {
+      return EFI_OUT_OF_RESOURCES;
+    }
+  }
+
+  //
+  // Lock
+  //
+  FatAcquireLock ();
+
+  //
+  // Open the file
+  //
+  Status = FatOFileOpen (OFile, &NewIFile, FileName, OpenMode, (UINT8) Attributes);
+
+  //
+  // If the file was opened, return the handle to the caller
+  //
+  if (!EFI_ERROR (Status)) {
+    *NewHandle = &NewIFile->Handle;
+  }
+  //
+  // Unlock
+  //
+  Status = FatCleanupVolume (OFile->Volume, NULL, Status, Task);
+  FatReleaseLock ();
+
+  if (Token != NULL) {
+    if (!EFI_ERROR (Status)) {
+      Status = FatQueueTask (IFile, Task);
+    } else {
+      FatDestroyTask (Task);
+    }
+  }
+
+  return Status;
+}
+
+/**
+
+  Implements Open() of Simple File System Protocol.
+
+
+  @param   FHand                 - File handle of the file serves as a starting reference point.
+  @param   NewHandle             - Handle of the file that is newly opened.
+  @param   FileName              - File name relative to FHand.
+  @param   OpenMode              - Open mode.
+  @param   Attributes            - Attributes to set if the file is created.
+
+  @retval EFI_INVALID_PARAMETER - The FileName is NULL or the file string is empty.
+                          The OpenMode is not supported.
+                          The Attributes is not the valid attributes.
+  @retval EFI_OUT_OF_RESOURCES  - Can not allocate the memory for file string.
+  @retval EFI_SUCCESS           - Open the file successfully.
+  @return Others                - The status of open file.
+
+**/
+EFI_STATUS
+EFIAPI
+FatOpen (
+  IN  EFI_FILE_PROTOCOL   *FHand,
+  OUT EFI_FILE_PROTOCOL   **NewHandle,
+  IN  CHAR16              *FileName,
+  IN  UINT64              OpenMode,
+  IN  UINT64              Attributes
+  )
+{
+  return FatOpenEx (FHand, NewHandle, FileName, OpenMode, Attributes, NULL);
+}
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/OpenVolume.c b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/OpenVolume.c
new file mode 100644
index 00000000..ecb01df7
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/OpenVolume.c
@@ -0,0 +1,58 @@
+/** @file
+  OpenVolume() function of Simple File System Protocol.
+
+Copyright (c) 2005 - 2013, Intel Corporation. All rights reserved.<BR>
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "Fat.h"
+
+/**
+
+  Implements Simple File System Protocol interface function OpenVolume().
+
+  @param  This                  - Calling context.
+  @param  File                  - the Root Directory of the volume.
+
+  @retval EFI_OUT_OF_RESOURCES  - Can not allocate the memory.
+  @retval EFI_VOLUME_CORRUPTED  - The FAT type is error.
+  @retval EFI_SUCCESS           - Open the volume successfully.
+
+**/
+EFI_STATUS
+EFIAPI
+FatOpenVolume (
+  IN  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL  *This,
+  OUT EFI_FILE_PROTOCOL                **File
+  )
+{
+  EFI_STATUS  Status;
+  FAT_VOLUME  *Volume;
+  FAT_IFILE   *IFile;
+
+  Volume = VOLUME_FROM_VOL_INTERFACE (This);
+  FatAcquireLock ();
+
+  //
+  // Open Root file
+  //
+  Status = FatOpenDirEnt (NULL, &Volume->RootDirEnt);
+  if (EFI_ERROR (Status)) {
+    goto Done;
+  }
+  //
+  // Open a new instance to the root
+  //
+  Status = FatAllocateIFile (Volume->Root, &IFile);
+  if (!EFI_ERROR (Status)) {
+    *File = &IFile->Handle;
+  }
+
+Done:
+
+  Status = FatCleanupVolume (Volume, Volume->Root, Status, NULL);
+  FatReleaseLock ();
+
+  return Status;
+}
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/ReadWrite.c b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/ReadWrite.c
new file mode 100644
index 00000000..f97a2163
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/ReadWrite.c
@@ -0,0 +1,620 @@
+/** @file
+  Functions that perform file read/write.
+
+Copyright (c) 2005 - 2017, Intel Corporation. All rights reserved.<BR>
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+
+**/
+
+#include "Fat.h"
+
+/**
+
+  Get the file's position of the file.
+
+
+  @param  FHand                 - The handle of file.
+  @param  Position              - The file's position of the file.
+
+  @retval EFI_SUCCESS           - Get the info successfully.
+  @retval EFI_DEVICE_ERROR      - Can not find the OFile for the file.
+  @retval EFI_UNSUPPORTED       - The open file is not a file.
+
+**/
+EFI_STATUS
+EFIAPI
+FatGetPosition (
+  IN  EFI_FILE_PROTOCOL *FHand,
+  OUT UINT64            *Position
+  )
+{
+  FAT_IFILE *IFile;
+  FAT_OFILE *OFile;
+
+  IFile = IFILE_FROM_FHAND (FHand);
+  OFile = IFile->OFile;
+
+  if (OFile->Error == EFI_NOT_FOUND) {
+    return EFI_DEVICE_ERROR;
+  }
+
+  if (OFile->ODir != NULL) {
+    return EFI_UNSUPPORTED;
+  }
+
+  *Position = IFile->Position;
+  return EFI_SUCCESS;
+}
+
+/**
+
+  Set the file's position of the file.
+
+  @param  FHand                 - The handle of file.
+  @param  Position              - The file's position of the file.
+
+  @retval EFI_SUCCESS           - Set the info successfully.
+  @retval EFI_DEVICE_ERROR      - Can not find the OFile for the file.
+  @retval EFI_UNSUPPORTED       - Set a directory with a not-zero position.
+
+**/
+EFI_STATUS
+EFIAPI
+FatSetPosition (
+  IN EFI_FILE_PROTOCOL  *FHand,
+  IN UINT64             Position
+  )
+{
+  FAT_IFILE *IFile;
+  FAT_OFILE *OFile;
+
+  IFile = IFILE_FROM_FHAND (FHand);
+  OFile = IFile->OFile;
+
+  if (OFile->Error == EFI_NOT_FOUND) {
+    return EFI_DEVICE_ERROR;
+  }
+
+  FatWaitNonblockingTask (IFile);
+
+  //
+  // If this is a directory, we can only set back to position 0
+  //
+  if (OFile->ODir != NULL) {
+    if (Position != 0) {
+      //
+      // Reset current directory cursor;
+      //
+      return EFI_UNSUPPORTED;
+    }
+
+    FatResetODirCursor (OFile);
+  }
+  //
+  // Set the position
+  //
+  if (Position == (UINT64)-1) {
+    Position = OFile->FileSize;
+  }
+  //
+  // Set the position
+  //
+  IFile->Position = Position;
+  return EFI_SUCCESS;
+}
+
+/**
+
+  Get the file info from the open file of the IFile into Buffer.
+
+  @param  IFile                 - The instance of the open file.
+  @param  BufferSize            - Size of Buffer.
+  @param  Buffer                - Buffer containing read data.
+
+  @retval EFI_SUCCESS           - Get the file info successfully.
+  @retval other                 - An error occurred when operation the disk.
+
+**/
+EFI_STATUS
+FatIFileReadDir (
+  IN     FAT_IFILE              *IFile,
+  IN OUT UINTN                  *BufferSize,
+     OUT VOID                   *Buffer
+  )
+{
+  EFI_STATUS  Status;
+  FAT_OFILE   *OFile;
+  FAT_ODIR    *ODir;
+  FAT_DIRENT  *DirEnt;
+  UINT32      CurrentPos;
+
+  OFile       = IFile->OFile;
+  ODir        = OFile->ODir;
+  CurrentPos  = ((UINT32) IFile->Position) / sizeof (FAT_DIRECTORY_ENTRY);
+
+  //
+  // We need to relocate the directory
+  //
+  if (CurrentPos < ODir->CurrentPos) {
+    //
+    // The directory cursor has been modified by another IFile, we reset the cursor
+    //
+    FatResetODirCursor (OFile);
+  }
+  //
+  // We seek the next directory entry's position
+  //
+  do {
+    Status = FatGetNextDirEnt (OFile, &DirEnt);
+    if (EFI_ERROR (Status) || DirEnt == NULL) {
+      //
+      // Something error occurred or reach the end of directory,
+      // return 0 buffersize
+      //
+      *BufferSize = 0;
+      goto Done;
+    }
+  } while (ODir->CurrentPos <= CurrentPos);
+  Status = FatGetDirEntInfo (OFile->Volume, DirEnt, BufferSize, Buffer);
+
+Done:
+  //
+  // Update IFile's Position
+  //
+  if (!EFI_ERROR (Status)) {
+    //
+    // Update IFile->Position, if everything is all right
+    //
+    CurrentPos      = ODir->CurrentPos;
+    IFile->Position = CurrentPos * sizeof (FAT_DIRECTORY_ENTRY);
+  }
+
+  return Status;
+}
+
+/**
+
+  Get the file info from the open file of the IFile into Buffer.
+
+  @param FHand                 - The file handle to access.
+  @param  IoMode                - Indicate whether the access mode is reading or writing.
+  @param  BufferSize            - Size of Buffer.
+  @param  Buffer                - Buffer containing read data.
+  @param  Token                 - A pointer to the token associated with the transaction.
+
+  @retval EFI_SUCCESS           - Get the file info successfully.
+  @retval EFI_DEVICE_ERROR      - Can not find the OFile for the file.
+  @retval EFI_VOLUME_CORRUPTED  - The file type of open file is error.
+  @retval EFI_WRITE_PROTECTED   - The disk is write protect.
+  @retval EFI_ACCESS_DENIED     - The file is read-only.
+  @return other                 - An error occurred when operating on the disk.
+
+**/
+EFI_STATUS
+FatIFileAccess (
+  IN     EFI_FILE_PROTOCOL     *FHand,
+  IN     IO_MODE               IoMode,
+  IN OUT UINTN                 *BufferSize,
+  IN OUT VOID                  *Buffer,
+  IN     EFI_FILE_IO_TOKEN     *Token
+  )
+{
+  EFI_STATUS  Status;
+  FAT_IFILE   *IFile;
+  FAT_OFILE   *OFile;
+  FAT_VOLUME  *Volume;
+  UINT64      EndPosition;
+  FAT_TASK    *Task;
+
+  IFile  = IFILE_FROM_FHAND (FHand);
+  OFile  = IFile->OFile;
+  Volume = OFile->Volume;
+  Task   = NULL;
+
+  //
+  // Write to a directory is unsupported
+  //
+  if ((OFile->ODir != NULL) && (IoMode == WriteData)) {
+    return EFI_UNSUPPORTED;
+  }
+
+  if (OFile->Error == EFI_NOT_FOUND) {
+    return EFI_DEVICE_ERROR;
+  }
+
+  if (IoMode == ReadData) {
+    //
+    // If position is at EOF, then return device error
+    //
+    if (IFile->Position > OFile->FileSize) {
+      return EFI_DEVICE_ERROR;
+    }
+  } else {
+    //
+    // Check if the we can write data
+    //
+    if (Volume->ReadOnly) {
+      return EFI_WRITE_PROTECTED;
+    }
+
+    if (IFile->ReadOnly) {
+      return EFI_ACCESS_DENIED;
+    }
+  }
+
+  if (Token == NULL) {
+    FatWaitNonblockingTask (IFile);
+  } else {
+    //
+    // Caller shouldn't call the non-blocking interfaces if the low layer doesn't support DiskIo2.
+    // But if it calls, the below check can avoid crash.
+    //
+    if (FHand->Revision < EFI_FILE_PROTOCOL_REVISION2) {
+      return EFI_UNSUPPORTED;
+    }
+    Task = FatCreateTask (IFile, Token);
+    if (Task == NULL) {
+      return EFI_OUT_OF_RESOURCES;
+    }
+  }
+
+  FatAcquireLock ();
+
+  Status = OFile->Error;
+  if (!EFI_ERROR (Status)) {
+    if (OFile->ODir != NULL) {
+      //
+      // Read a directory is supported
+      //
+      ASSERT (IoMode == ReadData);
+      Status = FatIFileReadDir (IFile, BufferSize, Buffer);
+      OFile = NULL;
+    } else {
+      //
+      // Access a file
+      //
+      EndPosition = IFile->Position + *BufferSize;
+      if (EndPosition > OFile->FileSize) {
+        //
+        // The position goes beyond the end of file
+        //
+        if (IoMode == ReadData) {
+          //
+          // Adjust the actual size read
+          //
+          *BufferSize -= (UINTN) EndPosition - OFile->FileSize;
+        } else {
+          //
+          // We expand the file size of OFile
+          //
+          Status = FatGrowEof (OFile, EndPosition);
+          if (EFI_ERROR (Status)) {
+            //
+            // Must update the file's info into the file's Directory Entry
+            // and then flush the dirty cache info into disk.
+            //
+            *BufferSize = 0;
+            FatOFileFlush (OFile);
+            OFile = NULL;
+            goto Done;
+          }
+
+          FatUpdateDirEntClusterSizeInfo (OFile);
+        }
+      }
+
+      Status = FatAccessOFile (OFile, IoMode, (UINTN) IFile->Position, BufferSize, Buffer, Task);
+      IFile->Position += *BufferSize;
+    }
+  }
+
+  if (Token != NULL) {
+    if (!EFI_ERROR (Status)) {
+      Status = FatQueueTask (IFile, Task);
+    } else {
+      FatDestroyTask (Task);
+    }
+  }
+
+Done:
+  //
+  // On EFI_SUCCESS case, not calling FatCleanupVolume():
+  // 1) The Cache flush operation is avoided to enhance
+  // performance. Caller is responsible to call Flush() when necessary.
+  // 2) The volume dirty bit is probably set already, and is expected to be
+  // cleaned in subsequent Flush() or other operations.
+  // 3) Write operation doesn't affect OFile/IFile structure, so
+  // Reference checking is not necessary.
+  //
+  if (EFI_ERROR (Status)) {
+    Status = FatCleanupVolume (Volume, OFile, Status, NULL);
+  }
+
+  FatReleaseLock ();
+  return Status;
+}
+
+/**
+
+  Get the file info.
+
+  @param  FHand                 - The handle of the file.
+  @param  BufferSize            - Size of Buffer.
+  @param  Buffer                - Buffer containing read data.
+
+
+  @retval EFI_SUCCESS           - Get the file info successfully.
+  @retval EFI_DEVICE_ERROR      - Can not find the OFile for the file.
+  @retval EFI_VOLUME_CORRUPTED  - The file type of open file is error.
+  @return other                 - An error occurred when operation the disk.
+
+**/
+EFI_STATUS
+EFIAPI
+FatRead (
+  IN     EFI_FILE_PROTOCOL  *FHand,
+  IN OUT UINTN              *BufferSize,
+     OUT VOID               *Buffer
+  )
+{
+  return FatIFileAccess (FHand, ReadData, BufferSize, Buffer, NULL);
+}
+
+/**
+
+  Get the file info.
+
+  @param  FHand                 - The handle of the file.
+  @param  Token                 - A pointer to the token associated with the transaction.
+
+  @retval EFI_SUCCESS           - Get the file info successfully.
+  @retval EFI_DEVICE_ERROR      - Can not find the OFile for the file.
+  @retval EFI_VOLUME_CORRUPTED  - The file type of open file is error.
+  @return other                 - An error occurred when operation the disk.
+
+**/
+EFI_STATUS
+EFIAPI
+FatReadEx (
+  IN     EFI_FILE_PROTOCOL  *FHand,
+  IN OUT EFI_FILE_IO_TOKEN  *Token
+  )
+{
+  return FatIFileAccess (FHand, ReadData, &Token->BufferSize, Token->Buffer, Token);
+}
+
+/**
+
+  Write the content of buffer into files.
+
+  @param  FHand                 - The handle of the file.
+  @param  BufferSize            - Size of Buffer.
+  @param  Buffer                - Buffer containing write data.
+
+  @retval EFI_SUCCESS           - Set the file info successfully.
+  @retval EFI_WRITE_PROTECTED   - The disk is write protect.
+  @retval EFI_ACCESS_DENIED     - The file is read-only.
+  @retval EFI_DEVICE_ERROR      - The OFile is not valid.
+  @retval EFI_UNSUPPORTED       - The open file is not a file.
+                        - The writing file size is larger than 4GB.
+  @return other                 - An error occurred when operation the disk.
+
+**/
+EFI_STATUS
+EFIAPI
+FatWrite (
+  IN     EFI_FILE_PROTOCOL  *FHand,
+  IN OUT UINTN              *BufferSize,
+  IN     VOID               *Buffer
+  )
+{
+  return FatIFileAccess (FHand, WriteData, BufferSize, Buffer, NULL);
+}
+
+/**
+
+  Get the file info.
+
+  @param  FHand                 - The handle of the file.
+  @param  Token                 - A pointer to the token associated with the transaction.
+
+  @retval EFI_SUCCESS           - Get the file info successfully.
+  @retval EFI_DEVICE_ERROR      - Can not find the OFile for the file.
+  @retval EFI_VOLUME_CORRUPTED  - The file type of open file is error.
+  @return other                 - An error occurred when operation the disk.
+
+**/
+EFI_STATUS
+EFIAPI
+FatWriteEx (
+  IN     EFI_FILE_PROTOCOL  *FHand,
+  IN OUT EFI_FILE_IO_TOKEN  *Token
+  )
+{
+  return FatIFileAccess (FHand, WriteData, &Token->BufferSize, Token->Buffer, Token);
+}
+
+/**
+
+  This function reads data from a file or writes data to a file.
+  It uses OFile->PosRem to determine how much data can be accessed in one time.
+
+  @param  OFile                 - The open file.
+  @param  IoMode                - Indicate whether the access mode is reading or writing.
+  @param  Position              - The position where data will be accessed.
+  @param  DataBufferSize        - Size of Buffer.
+  @param  UserBuffer            - Buffer containing data.
+  @param  Task                    point to task instance.
+
+  @retval EFI_SUCCESS           - Access the data successfully.
+  @return other                 - An error occurred when operating on the disk.
+
+**/
+EFI_STATUS
+FatAccessOFile (
+  IN     FAT_OFILE      *OFile,
+  IN     IO_MODE        IoMode,
+  IN     UINTN          Position,
+  IN OUT UINTN          *DataBufferSize,
+  IN OUT UINT8          *UserBuffer,
+  IN FAT_TASK           *Task
+  )
+{
+  FAT_VOLUME  *Volume;
+  UINTN       Len;
+  EFI_STATUS  Status;
+  UINTN       BufferSize;
+
+  BufferSize  = *DataBufferSize;
+  Volume      = OFile->Volume;
+  ASSERT_VOLUME_LOCKED (Volume);
+
+  Status = EFI_SUCCESS;
+  while (BufferSize > 0) {
+    //
+    // Seek the OFile to the file position
+    //
+    Status = FatOFilePosition (OFile, Position, BufferSize);
+    if (EFI_ERROR (Status)) {
+      break;
+    }
+    //
+    // Clip length to block run
+    //
+    Len = BufferSize > OFile->PosRem ? OFile->PosRem : BufferSize;
+
+    //
+    // Write the data
+    //
+    Status = FatDiskIo (Volume, IoMode, OFile->PosDisk, Len, UserBuffer, Task);
+    if (EFI_ERROR (Status)) {
+      break;
+    }
+    //
+    // Data was successfully accessed
+    //
+    Position   += Len;
+    UserBuffer += Len;
+    BufferSize -= Len;
+    if (IoMode == WriteData) {
+      OFile->Dirty    = TRUE;
+      OFile->Archive  = TRUE;
+    }
+    //
+    // Make sure no outbound occurred
+    //
+    ASSERT (Position <= OFile->FileSize);
+  }
+  //
+  // Update the number of bytes accessed
+  //
+  *DataBufferSize -= BufferSize;
+  return Status;
+}
+
+/**
+
+  Expand OFile by appending zero bytes at the end of OFile.
+
+  @param  OFile                 - The open file.
+  @param  ExpandedSize          - The number of zero bytes appended at the end of the file.
+
+  @retval EFI_SUCCESS           - The file is expanded successfully.
+  @return other                 - An error occurred when expanding file.
+
+**/
+EFI_STATUS
+FatExpandOFile (
+  IN FAT_OFILE          *OFile,
+  IN UINT64             ExpandedSize
+  )
+{
+  EFI_STATUS  Status;
+  UINTN       WritePos;
+
+  WritePos  = OFile->FileSize;
+  Status    = FatGrowEof (OFile, ExpandedSize);
+  if (!EFI_ERROR (Status)) {
+    Status = FatWriteZeroPool (OFile, WritePos);
+  }
+
+  return Status;
+}
+
+/**
+
+  Write zero pool from the WritePos to the end of OFile.
+
+  @param  OFile                 - The open file to write zero pool.
+  @param  WritePos              - The number of zero bytes written.
+
+  @retval EFI_SUCCESS           - Write the zero pool successfully.
+  @retval EFI_OUT_OF_RESOURCES  - Not enough memory to perform the operation.
+  @return other                 - An error occurred when writing disk.
+
+**/
+EFI_STATUS
+FatWriteZeroPool (
+  IN FAT_OFILE  *OFile,
+  IN UINTN      WritePos
+  )
+{
+  EFI_STATUS  Status;
+  VOID        *ZeroBuffer;
+  UINTN       AppendedSize;
+  UINTN       BufferSize;
+  UINTN       WriteSize;
+
+  AppendedSize  = OFile->FileSize - WritePos;
+  BufferSize    = AppendedSize;
+  if (AppendedSize > FAT_MAX_ALLOCATE_SIZE) {
+    //
+    // If the appended size is larger, maybe we can not allocate the whole
+    // memory once. So if the growed size is larger than 10M, we just
+    // allocate 10M memory (one healthy system should have 10M available
+    // memory), and then write the zerobuffer to the file several times.
+    //
+    BufferSize = FAT_MAX_ALLOCATE_SIZE;
+  }
+
+  ZeroBuffer = AllocateZeroPool (BufferSize);
+  if (ZeroBuffer == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  do {
+    WriteSize     = AppendedSize > BufferSize ? BufferSize : (UINTN) AppendedSize;
+    AppendedSize -= WriteSize;
+    Status = FatAccessOFile (OFile, WriteData, WritePos, &WriteSize, ZeroBuffer, NULL);
+    if (EFI_ERROR (Status)) {
+      break;
+    }
+
+    WritePos += WriteSize;
+  } while (AppendedSize > 0);
+
+  FreePool (ZeroBuffer);
+  return Status;
+}
+
+/**
+
+  Truncate the OFile to smaller file size.
+
+  @param  OFile                 - The open file.
+  @param  TruncatedSize         - The new file size.
+
+  @retval EFI_SUCCESS           - The file is truncated successfully.
+  @return other                 - An error occurred when truncating file.
+
+**/
+EFI_STATUS
+FatTruncateOFile (
+  IN FAT_OFILE          *OFile,
+  IN UINTN              TruncatedSize
+  )
+{
+  OFile->FileSize = TruncatedSize;
+  return FatShrinkEof (OFile);
+}
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/UnicodeCollation.c b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/UnicodeCollation.c
new file mode 100644
index 00000000..48bd203a
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/EnhancedFatDxe/UnicodeCollation.c
@@ -0,0 +1,275 @@
+/** @file
+  Unicode Collation Support component that hides the trivial difference of Unicode Collation
+  and Unicode collation 2 Protocol.
+
+  Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>
+  SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "Fat.h"
+
+EFI_UNICODE_COLLATION_PROTOCOL  *mUnicodeCollationInterface = NULL;
+
+/**
+  Worker function to initialize Unicode Collation support.
+
+  It tries to locate Unicode Collation (2) protocol and matches it with current
+  platform language code.
+
+  @param  AgentHandle          The handle used to open Unicode Collation (2) protocol.
+  @param  ProtocolGuid         The pointer to Unicode Collation (2) protocol GUID.
+  @param  VariableName         The name of the RFC 4646 or ISO 639-2 language variable.
+  @param  DefaultLanguage      The default language in case the RFC 4646 or ISO 639-2 language is absent.
+
+  @retval EFI_SUCCESS          The Unicode Collation (2) protocol has been successfully located.
+  @retval Others               The Unicode Collation (2) protocol has not been located.
+
+**/
+EFI_STATUS
+InitializeUnicodeCollationSupportWorker (
+  IN EFI_HANDLE         AgentHandle,
+  IN EFI_GUID           *ProtocolGuid,
+  IN CONST CHAR16       *VariableName,
+  IN CONST CHAR8        *DefaultLanguage
+  )
+{
+  EFI_STATUS                      ReturnStatus;
+  EFI_STATUS                      Status;
+  UINTN                           NumHandles;
+  UINTN                           Index;
+  EFI_HANDLE                      *Handles;
+  EFI_UNICODE_COLLATION_PROTOCOL  *Uci;
+  BOOLEAN                         Iso639Language;
+  CHAR8                           *Language;
+  CHAR8                           *BestLanguage;
+
+  Status = gBS->LocateHandleBuffer (
+                  ByProtocol,
+                  ProtocolGuid,
+                  NULL,
+                  &NumHandles,
+                  &Handles
+                  );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  Iso639Language = (BOOLEAN) (ProtocolGuid == &gEfiUnicodeCollationProtocolGuid);
+  GetEfiGlobalVariable2 (VariableName, (VOID**) &Language, NULL);
+
+  ReturnStatus = EFI_UNSUPPORTED;
+  for (Index = 0; Index < NumHandles; Index++) {
+    //
+    // Open Unicode Collation Protocol
+    //
+    Status = gBS->OpenProtocol (
+                    Handles[Index],
+                    ProtocolGuid,
+                    (VOID **) &Uci,
+                    AgentHandle,
+                    NULL,
+                    EFI_OPEN_PROTOCOL_GET_PROTOCOL
+                    );
+    if (EFI_ERROR (Status)) {
+      continue;
+    }
+
+    //
+    // Find the best matching matching language from the supported languages
+    // of Unicode Collation (2) protocol.
+    //
+    BestLanguage = GetBestLanguage (
+                     Uci->SupportedLanguages,
+                     Iso639Language,
+                     (Language == NULL) ? "" : Language,
+                     DefaultLanguage,
+                     NULL
+                     );
+    if (BestLanguage != NULL) {
+      FreePool (BestLanguage);
+      mUnicodeCollationInterface = Uci;
+      ReturnStatus = EFI_SUCCESS;
+      break;
+    }
+  }
+
+  if (Language != NULL) {
+    FreePool (Language);
+  }
+
+  FreePool (Handles);
+
+  return ReturnStatus;
+}
+
+/**
+  Initialize Unicode Collation support.
+
+  It tries to locate Unicode Collation 2 protocol and matches it with current
+  platform language code. If for any reason the first attempt fails, it then tries to
+  use Unicode Collation Protocol.
+
+  @param  AgentHandle          The handle used to open Unicode Collation (2) protocol.
+
+  @retval EFI_SUCCESS          The Unicode Collation (2) protocol has been successfully located.
+  @retval Others               The Unicode Collation (2) protocol has not been located.
+
+**/
+EFI_STATUS
+InitializeUnicodeCollationSupport (
+  IN EFI_HANDLE    AgentHandle
+  )
+{
+
+  EFI_STATUS       Status;
+
+  Status = EFI_UNSUPPORTED;
+
+  //
+  // First try to use RFC 4646 Unicode Collation 2 Protocol.
+  //
+  Status = InitializeUnicodeCollationSupportWorker (
+             AgentHandle,
+             &gEfiUnicodeCollation2ProtocolGuid,
+             L"PlatformLang",
+             (CONST CHAR8 *) PcdGetPtr (PcdUefiVariableDefaultPlatformLang)
+             );
+  //
+  // If the attempt to use Unicode Collation 2 Protocol fails, then we fall back
+  // on the ISO 639-2 Unicode Collation Protocol.
+  //
+  if (EFI_ERROR (Status)) {
+    Status = InitializeUnicodeCollationSupportWorker (
+               AgentHandle,
+               &gEfiUnicodeCollationProtocolGuid,
+               L"Lang",
+               (CONST CHAR8 *) PcdGetPtr (PcdUefiVariableDefaultLang)
+               );
+  }
+
+  return Status;
+}
+
+
+/**
+  Performs a case-insensitive comparison of two Null-terminated Unicode strings.
+
+  @param  S1                   A pointer to a Null-terminated Unicode string.
+  @param  S2                   A pointer to a Null-terminated Unicode string.
+
+  @retval 0                    S1 is equivalent to S2.
+  @retval >0                   S1 is lexically greater than S2.
+  @retval <0                   S1 is lexically less than S2.
+**/
+INTN
+FatStriCmp (
+  IN CHAR16       *S1,
+  IN CHAR16       *S2
+  )
+{
+  ASSERT (StrSize (S1) != 0);
+  ASSERT (StrSize (S2) != 0);
+  ASSERT (mUnicodeCollationInterface != NULL);
+
+  return mUnicodeCollationInterface->StriColl (
+                                       mUnicodeCollationInterface,
+                                       S1,
+                                       S2
+                                       );
+}
+
+
+/**
+  Uppercase a string.
+
+  @param  String                   The string which will be upper-cased.
+
+
+**/
+VOID
+FatStrUpr (
+  IN OUT CHAR16   *String
+  )
+{
+  ASSERT (StrSize (String) != 0);
+  ASSERT (mUnicodeCollationInterface != NULL);
+
+  mUnicodeCollationInterface->StrUpr (mUnicodeCollationInterface, String);
+}
+
+
+/**
+  Lowercase a string
+
+  @param  String                   The string which will be lower-cased.
+
+
+**/
+VOID
+FatStrLwr (
+  IN OUT CHAR16   *String
+  )
+{
+  ASSERT (StrSize (String) != 0);
+  ASSERT (mUnicodeCollationInterface != NULL);
+
+  mUnicodeCollationInterface->StrLwr (mUnicodeCollationInterface, String);
+}
+
+
+/**
+  Convert FAT string to unicode string.
+
+  @param  FatSize               The size of FAT string.
+  @param  Fat                   The FAT string.
+  @param  String                The unicode string.
+
+  @return None.
+
+**/
+VOID
+FatFatToStr (
+  IN  UINTN                            FatSize,
+  IN  CHAR8                            *Fat,
+  OUT CHAR16                           *String
+  )
+{
+  ASSERT (Fat != NULL);
+  ASSERT (String != NULL);
+  ASSERT (((UINTN) String & 0x01) == 0);
+  ASSERT (mUnicodeCollationInterface != NULL);
+
+  mUnicodeCollationInterface->FatToStr (mUnicodeCollationInterface, FatSize, Fat, String);
+}
+
+
+/**
+  Convert unicode string to Fat string.
+
+  @param  String                The unicode string.
+  @param  FatSize               The size of the FAT string.
+  @param  Fat                   The FAT string.
+
+  @retval TRUE                  Convert successfully.
+  @retval FALSE                 Convert error.
+
+**/
+BOOLEAN
+FatStrToFat (
+  IN  CHAR16                          *String,
+  IN  UINTN                           FatSize,
+  OUT CHAR8                           *Fat
+  )
+{
+  ASSERT (Fat != NULL);
+  ASSERT (StrSize (String) != 0);
+  ASSERT (mUnicodeCollationInterface != NULL);
+
+  return mUnicodeCollationInterface->StrToFat (
+                                       mUnicodeCollationInterface,
+                                       String,
+                                       FatSize,
+                                       Fat
+                                       );
+}
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/Eltorito.c b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/Eltorito.c
new file mode 100644
index 00000000..73ad56a2
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/Eltorito.c
@@ -0,0 +1,233 @@
+/** @file
+  Routines supporting partition discovery and
+  logical device reading
+
+Copyright (c) 2006 - 2019, Intel Corporation. All rights reserved.<BR>
+
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include <IndustryStandard/ElTorito.h>
+#include "FatLitePeim.h"
+
+/**
+  This function finds Eltorito partitions. Main algorithm
+  is ported from DXE partition driver.
+
+  @param[in]  PrivateData       The global memory map
+  @param[in]  ParentBlockDevNo  The parent block device
+
+  @retval TRUE              New partitions are detected and logical block devices
+                            are added to block device array
+  @retval FALSE             No new partitions are added
+
+**/
+BOOLEAN
+FatFindEltoritoPartitions (
+  IN  PEI_FAT_PRIVATE_DATA *PrivateData,
+  IN  UINTN                ParentBlockDevNo
+  )
+{
+  EFI_STATUS              Status;
+  BOOLEAN                 Found;
+  PEI_FAT_BLOCK_DEVICE    *BlockDev;
+  PEI_FAT_BLOCK_DEVICE    *ParentBlockDev;
+  UINT32                  VolDescriptorLba;
+  UINT32                  Lba;
+  CDROM_VOLUME_DESCRIPTOR *VolDescriptor;
+  ELTORITO_CATALOG        *Catalog;
+  UINTN                   Check;
+  UINTN                   Index;
+  UINTN                   MaxIndex;
+  UINT16                  *CheckBuffer;
+  UINT32                  SubBlockSize;
+  UINT32                  SectorCount;
+  UINT32                  VolSpaceSize;
+
+  if (ParentBlockDevNo > PEI_FAT_MAX_BLOCK_DEVICE - 1) {
+    return FALSE;
+  }
+
+  Found           = FALSE;
+  ParentBlockDev  = &(PrivateData->BlockDevice[ParentBlockDevNo]);
+  VolSpaceSize    = 0;
+
+  //
+  // CD_ROM has the fixed block size as 2048 bytes
+  //
+  if (ParentBlockDev->BlockSize != 2048) {
+    return FALSE;
+  }
+
+  VolDescriptor = (CDROM_VOLUME_DESCRIPTOR *) PrivateData->BlockData;
+  Catalog       = (ELTORITO_CATALOG *) VolDescriptor;
+
+  //
+  // the ISO-9660 volume descriptor starts at 32k on the media
+  // and CD_ROM has the fixed block size as 2048 bytes, so...
+  //
+  VolDescriptorLba = 15;
+  //
+  // ((16*2048) / Media->BlockSize) - 1;
+  //
+  // Loop: handle one volume descriptor per time
+  //
+  while (TRUE) {
+
+    VolDescriptorLba += 1;
+    if (VolDescriptorLba > ParentBlockDev->LastBlock) {
+      //
+      // We are pointing past the end of the device so exit
+      //
+      break;
+    }
+
+    Status = FatReadBlock (
+              PrivateData,
+              ParentBlockDevNo,
+              VolDescriptorLba,
+              ParentBlockDev->BlockSize,
+              VolDescriptor
+              );
+    if (EFI_ERROR (Status)) {
+      break;
+    }
+    //
+    // Check for valid volume descriptor signature
+    //
+    if (VolDescriptor->Unknown.Type == CDVOL_TYPE_END ||
+        CompareMem (VolDescriptor->Unknown.Id, CDVOL_ID, sizeof (VolDescriptor->Unknown.Id)) != 0
+        ) {
+      //
+      // end of Volume descriptor list
+      //
+      break;
+    }
+    //
+    // Read the Volume Space Size from Primary Volume Descriptor 81-88 byte
+    //
+    if (VolDescriptor->Unknown.Type == CDVOL_TYPE_CODED) {
+      VolSpaceSize = VolDescriptor->PrimaryVolume.VolSpaceSize[1];
+    }
+    //
+    // Is it an El Torito volume descriptor?
+    //
+    if (CompareMem (
+          VolDescriptor->BootRecordVolume.SystemId,
+          CDVOL_ELTORITO_ID,
+          sizeof (CDVOL_ELTORITO_ID) - 1
+          ) != 0) {
+      continue;
+    }
+    //
+    // Read in the boot El Torito boot catalog
+    //
+    Lba = UNPACK_INT32 (VolDescriptor->BootRecordVolume.EltCatalog);
+    if (Lba > ParentBlockDev->LastBlock) {
+      continue;
+    }
+
+    Status = FatReadBlock (
+              PrivateData,
+              ParentBlockDevNo,
+              Lba,
+              ParentBlockDev->BlockSize,
+              Catalog
+              );
+    if (EFI_ERROR (Status)) {
+      continue;
+    }
+    //
+    // We don't care too much about the Catalog header's contents, but we do want
+    // to make sure it looks like a Catalog header
+    //
+    if (Catalog->Catalog.Indicator != ELTORITO_ID_CATALOG || Catalog->Catalog.Id55AA != 0xAA55) {
+      continue;
+    }
+
+    Check       = 0;
+    CheckBuffer = (UINT16 *) Catalog;
+    for (Index = 0; Index < sizeof (ELTORITO_CATALOG) / sizeof (UINT16); Index += 1) {
+      Check += CheckBuffer[Index];
+    }
+
+    if ((Check & 0xFFFF) != 0) {
+      continue;
+    }
+
+    MaxIndex = ParentBlockDev->BlockSize / sizeof (ELTORITO_CATALOG);
+    for (Index = 1; Index < MaxIndex; Index += 1) {
+      //
+      // Next entry
+      //
+      Catalog += 1;
+
+      //
+      // Check this entry
+      //
+      if (Catalog->Boot.Indicator != ELTORITO_ID_SECTION_BOOTABLE || Catalog->Boot.Lba == 0) {
+        continue;
+      }
+
+      SubBlockSize  = 512;
+      SectorCount   = Catalog->Boot.SectorCount;
+
+      switch (Catalog->Boot.MediaType) {
+
+      case ELTORITO_NO_EMULATION:
+        SubBlockSize  = ParentBlockDev->BlockSize;
+        SectorCount   = Catalog->Boot.SectorCount;
+        break;
+
+      case ELTORITO_HARD_DISK:
+        break;
+
+      case ELTORITO_12_DISKETTE:
+        SectorCount = 0x50 * 0x02 * 0x0F;
+        break;
+
+      case ELTORITO_14_DISKETTE:
+        SectorCount = 0x50 * 0x02 * 0x12;
+        break;
+
+      case ELTORITO_28_DISKETTE:
+        SectorCount = 0x50 * 0x02 * 0x24;
+        break;
+
+      default:
+        SectorCount   = 0;
+        SubBlockSize  = ParentBlockDev->BlockSize;
+        break;
+      }
+
+      if (SectorCount < 2) {
+        SectorCount = (VolSpaceSize > ParentBlockDev->LastBlock + 1) ? (UINT32) (ParentBlockDev->LastBlock - Catalog->Boot.Lba + 1) : (UINT32) (VolSpaceSize - Catalog->Boot.Lba);
+      }
+      //
+      // Register this partition
+      //
+      if (PrivateData->BlockDeviceCount < PEI_FAT_MAX_BLOCK_DEVICE) {
+
+        Found                       = TRUE;
+
+        BlockDev                    = &(PrivateData->BlockDevice[PrivateData->BlockDeviceCount]);
+
+        BlockDev->BlockSize         = SubBlockSize;
+        BlockDev->LastBlock         = SectorCount - 1;
+        BlockDev->IoAlign           = ParentBlockDev->IoAlign;
+        BlockDev->Logical           = TRUE;
+        BlockDev->PartitionChecked  = FALSE;
+        BlockDev->StartingPos       = MultU64x32 (Catalog->Boot.Lba, ParentBlockDev->BlockSize);
+        BlockDev->ParentDevNo       = ParentBlockDevNo;
+
+        PrivateData->BlockDeviceCount++;
+      }
+    }
+  }
+
+  ParentBlockDev->PartitionChecked = TRUE;
+
+  return Found;
+
+}
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/FatLiteAccess.c b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/FatLiteAccess.c
new file mode 100644
index 00000000..99168513
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/FatLiteAccess.c
@@ -0,0 +1,521 @@
+/** @file
+  FAT file system access routines for FAT recovery PEIM
+
+Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>
+
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "FatLitePeim.h"
+
+
+/**
+  Check if there is a valid FAT in the corresponding Block device
+  of the volume and if yes, fill in the relevant fields for the
+  volume structure. Note there should be a valid Block device number
+  already set.
+
+  @param  PrivateData            Global memory map for accessing global
+                                 variables.
+  @param  Volume                 On input, the BlockDeviceNumber field of the
+                                 Volume  should be a valid value. On successful
+                                 output, all  fields except the VolumeNumber
+                                 field is initialized.
+
+  @retval EFI_SUCCESS            A FAT is found and the volume structure is
+                                 initialized.
+  @retval EFI_NOT_FOUND          There is no FAT on the corresponding device.
+  @retval EFI_DEVICE_ERROR       There is something error while accessing device.
+
+**/
+EFI_STATUS
+FatGetBpbInfo (
+  IN      PEI_FAT_PRIVATE_DATA  *PrivateData,
+  IN OUT  PEI_FAT_VOLUME        *Volume
+  )
+{
+  EFI_STATUS              Status;
+  PEI_FAT_BOOT_SECTOR     Bpb;
+  PEI_FAT_BOOT_SECTOR_EX  BpbEx;
+  UINT32                  Sectors;
+  UINT32                  SectorsPerFat;
+  UINT32                  RootDirSectors;
+  UINT64                  FatLba;
+  UINT64                  RootLba;
+  UINT64                  FirstClusterLba;
+
+  //
+  // Read in the BPB
+  //
+  Status = FatReadDisk (
+            PrivateData,
+            Volume->BlockDeviceNo,
+            0,
+            sizeof (PEI_FAT_BOOT_SECTOR_EX),
+            &BpbEx
+            );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  CopyMem (
+    (UINT8 *) (&Bpb),
+    (UINT8 *) (&BpbEx),
+    sizeof (PEI_FAT_BOOT_SECTOR)
+    );
+
+  Volume->FatType = FatUnknown;
+
+  Sectors         = Bpb.Sectors;
+  if (Sectors == 0) {
+    Sectors = Bpb.LargeSectors;
+  }
+
+  SectorsPerFat = Bpb.SectorsPerFat;
+  if (SectorsPerFat == 0) {
+    SectorsPerFat   = BpbEx.LargeSectorsPerFat;
+    Volume->FatType = Fat32;
+  }
+  //
+  // Filter out those not a FAT
+  //
+  if (Bpb.Ia32Jump[0] != 0xe9 && Bpb.Ia32Jump[0] != 0xeb && Bpb.Ia32Jump[0] != 0x49) {
+    return EFI_NOT_FOUND;
+  }
+
+  if (Bpb.ReservedSectors == 0 || Bpb.NoFats == 0 || Sectors == 0) {
+    return EFI_NOT_FOUND;
+  }
+
+  if (Bpb.SectorsPerCluster != 1 &&
+      Bpb.SectorsPerCluster != 2 &&
+      Bpb.SectorsPerCluster != 4 &&
+      Bpb.SectorsPerCluster != 8 &&
+      Bpb.SectorsPerCluster != 16 &&
+      Bpb.SectorsPerCluster != 32 &&
+      Bpb.SectorsPerCluster != 64 &&
+      Bpb.SectorsPerCluster != 128
+      ) {
+    return EFI_NOT_FOUND;
+  }
+
+  if (Volume->FatType == Fat32 && (SectorsPerFat == 0 || BpbEx.FsVersion != 0)) {
+    return EFI_NOT_FOUND;
+  }
+
+  if (Bpb.Media != 0xf0 &&
+      Bpb.Media != 0xf8 &&
+      Bpb.Media != 0xf9 &&
+      Bpb.Media != 0xfb &&
+      Bpb.Media != 0xfc &&
+      Bpb.Media != 0xfd &&
+      Bpb.Media != 0xfe &&
+      Bpb.Media != 0xff &&
+      //
+      // FujitsuFMR
+      //
+      Bpb.Media != 0x00 &&
+      Bpb.Media != 0x01 &&
+      Bpb.Media != 0xfa
+      ) {
+    return EFI_NOT_FOUND;
+  }
+
+  if (Volume->FatType != Fat32 && Bpb.RootEntries == 0) {
+    return EFI_NOT_FOUND;
+  }
+  //
+  // If this is fat32, refuse to mount mirror-disabled volumes
+  //
+  if (Volume->FatType == Fat32 && ((BpbEx.ExtendedFlags & 0x80) != 0)) {
+    return EFI_NOT_FOUND;
+  }
+  //
+  // Fill in the volume structure fields
+  // (Sectors & SectorsPerFat is computed earlier already)
+  //
+  Volume->ClusterSize = Bpb.SectorSize * Bpb.SectorsPerCluster;
+  Volume->RootEntries = Bpb.RootEntries;
+  Volume->SectorSize  = Bpb.SectorSize;
+
+  RootDirSectors = ((Volume->RootEntries * sizeof (FAT_DIRECTORY_ENTRY)) + (Volume->SectorSize - 1)) / Volume->SectorSize;
+
+  FatLba                  = Bpb.ReservedSectors;
+  RootLba                 = Bpb.NoFats * SectorsPerFat + FatLba;
+  FirstClusterLba         = RootLba + RootDirSectors;
+
+  Volume->VolumeSize      = MultU64x32 (Sectors, Volume->SectorSize);
+  Volume->FatPos          = MultU64x32 (FatLba, Volume->SectorSize);
+  Volume->RootDirPos      = MultU64x32 (RootLba, Volume->SectorSize);
+  Volume->FirstClusterPos = MultU64x32 (FirstClusterLba, Volume->SectorSize);
+  Volume->MaxCluster      = (UINT32) (Sectors - FirstClusterLba) / Bpb.SectorsPerCluster;
+  Volume->RootDirCluster  = BpbEx.RootDirFirstCluster;
+
+  //
+  // If this is not a fat32, determine if it's a fat16 or fat12
+  //
+  if (Volume->FatType != Fat32) {
+
+    if (Volume->MaxCluster >= 65525) {
+      return EFI_NOT_FOUND;
+    }
+
+    Volume->FatType = Volume->MaxCluster < 4085 ? Fat12 : Fat16;
+  }
+
+  return EFI_SUCCESS;
+}
+
+
+/**
+  Gets the next cluster in the cluster chain
+
+  @param  PrivateData            Global memory map for accessing global variables
+  @param  Volume                 The volume
+  @param  Cluster                The cluster
+  @param  NextCluster            The cluster number of the next cluster
+
+  @retval EFI_SUCCESS            The address is got
+  @retval EFI_INVALID_PARAMETER  ClusterNo exceeds the MaxCluster of the volume.
+  @retval EFI_DEVICE_ERROR       Read disk error
+
+**/
+EFI_STATUS
+FatGetNextCluster (
+  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
+  IN  PEI_FAT_VOLUME        *Volume,
+  IN  UINT32                Cluster,
+  OUT UINT32                *NextCluster
+  )
+{
+  EFI_STATUS  Status;
+  UINT64      FatEntryPos;
+  UINT32      Dummy;
+
+  *NextCluster = 0;
+
+  if (Volume->FatType == Fat32) {
+    FatEntryPos = Volume->FatPos + MultU64x32 (4, Cluster);
+
+    Status      = FatReadDisk (PrivateData, Volume->BlockDeviceNo, FatEntryPos, 4, NextCluster);
+    *NextCluster &= 0x0fffffff;
+
+    //
+    // Pad high bits for our FAT_CLUSTER_... macro definitions to work
+    //
+    if ((*NextCluster) >= 0x0ffffff7) {
+      *NextCluster |= (-1 &~0xf);
+    }
+
+  } else if (Volume->FatType == Fat16) {
+    FatEntryPos = Volume->FatPos + MultU64x32 (2, Cluster);
+
+    Status      = FatReadDisk (PrivateData, Volume->BlockDeviceNo, FatEntryPos, 2, NextCluster);
+
+    //
+    // Pad high bits for our FAT_CLUSTER_... macro definitions to work
+    //
+    if ((*NextCluster) >= 0xfff7) {
+      *NextCluster |= (-1 &~0xf);
+    }
+
+  } else {
+    FatEntryPos = Volume->FatPos + DivU64x32Remainder (MultU64x32 (3, Cluster), 2, &Dummy);
+
+    Status      = FatReadDisk (PrivateData, Volume->BlockDeviceNo, FatEntryPos, 2, NextCluster);
+
+    if ((Cluster & 0x01) != 0) {
+      *NextCluster = (*NextCluster) >> 4;
+    } else {
+      *NextCluster = (*NextCluster) & 0x0fff;
+    }
+    //
+    // Pad high bits for our FAT_CLUSTER_... macro definitions to work
+    //
+    if ((*NextCluster) >= 0x0ff7) {
+      *NextCluster |= (-1 &~0xf);
+    }
+  }
+
+  if (EFI_ERROR (Status)) {
+    return EFI_DEVICE_ERROR;
+  }
+
+  return EFI_SUCCESS;
+
+}
+
+
+/**
+  Set a file's CurrentPos and CurrentCluster, then compute StraightReadAmount.
+
+  @param  PrivateData            the global memory map
+  @param  File                   the file
+  @param  Pos                    the Position which is offset from the file's
+                                 CurrentPos
+
+  @retval EFI_SUCCESS            Success.
+  @retval EFI_INVALID_PARAMETER  Pos is beyond file's size.
+  @retval EFI_DEVICE_ERROR       Something error while accessing media.
+
+**/
+EFI_STATUS
+FatSetFilePos (
+  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
+  IN  PEI_FAT_FILE          *File,
+  IN  UINT32                Pos
+  )
+{
+  EFI_STATUS  Status;
+  UINT32      AlignedPos;
+  UINT32      Offset;
+  UINT32      Cluster;
+  UINT32      PrevCluster;
+
+  if (File->IsFixedRootDir) {
+
+    if (Pos >= MultU64x32 (File->Volume->RootEntries, 32) - File->CurrentPos) {
+      return EFI_INVALID_PARAMETER;
+    }
+
+    File->CurrentPos += Pos;
+    File->StraightReadAmount = (UINT32) (MultU64x32 (File->Volume->RootEntries, 32) - File->CurrentPos);
+
+  } else {
+
+    DivU64x32Remainder (File->CurrentPos, File->Volume->ClusterSize, &Offset);
+    AlignedPos = (UINT32) File->CurrentPos - (UINT32) Offset;
+
+    while
+    (
+      !FAT_CLUSTER_FUNCTIONAL (File->CurrentCluster) &&
+      AlignedPos + File->Volume->ClusterSize <= File->CurrentPos + Pos
+    ) {
+      AlignedPos += File->Volume->ClusterSize;
+      Status = FatGetNextCluster (
+                PrivateData,
+                File->Volume,
+                File->CurrentCluster,
+                &File->CurrentCluster
+                );
+      if (EFI_ERROR (Status)) {
+        return EFI_DEVICE_ERROR;
+      }
+    }
+
+    if (FAT_CLUSTER_FUNCTIONAL (File->CurrentCluster)) {
+      return EFI_INVALID_PARAMETER;
+    }
+
+    File->CurrentPos += Pos;
+    //
+    // Calculate the amount of consecutive cluster occupied by the file.
+    // FatReadFile() will use it to read these blocks once.
+    //
+    File->StraightReadAmount  = 0;
+    Cluster                   = File->CurrentCluster;
+    while (!FAT_CLUSTER_FUNCTIONAL (Cluster)) {
+      File->StraightReadAmount += File->Volume->ClusterSize;
+      PrevCluster = Cluster;
+      Status      = FatGetNextCluster (PrivateData, File->Volume, Cluster, &Cluster);
+      if (EFI_ERROR (Status)) {
+        return EFI_DEVICE_ERROR;
+      }
+
+      if (Cluster != PrevCluster + 1) {
+        break;
+      }
+    }
+
+    DivU64x32Remainder (File->CurrentPos, File->Volume->ClusterSize, &Offset);
+    File->StraightReadAmount -= (UINT32) Offset;
+
+  }
+
+  return EFI_SUCCESS;
+}
+
+
+/**
+  Reads file data. Updates the file's CurrentPos.
+
+  @param  PrivateData            Global memory map for accessing global variables
+  @param  File                   The file.
+  @param  Size                   The amount of data to read.
+  @param  Buffer                 The buffer storing the data.
+
+  @retval EFI_SUCCESS            The data is read.
+  @retval EFI_INVALID_PARAMETER  File is invalid.
+  @retval EFI_DEVICE_ERROR       Something error while accessing media.
+
+**/
+EFI_STATUS
+FatReadFile (
+  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
+  IN  PEI_FAT_FILE          *File,
+  IN  UINTN                 Size,
+  OUT VOID                  *Buffer
+  )
+{
+  EFI_STATUS  Status;
+  CHAR8       *BufferPtr;
+  UINT32      Offset;
+  UINT64      PhysicalAddr;
+  UINTN       Amount;
+
+  BufferPtr = Buffer;
+
+  if (File->IsFixedRootDir) {
+    //
+    // This is the fixed root dir in FAT12 and FAT16
+    //
+    if (File->CurrentPos + Size > File->Volume->RootEntries * sizeof (FAT_DIRECTORY_ENTRY)) {
+      return EFI_INVALID_PARAMETER;
+    }
+
+    Status = FatReadDisk (
+              PrivateData,
+              File->Volume->BlockDeviceNo,
+              File->Volume->RootDirPos + File->CurrentPos,
+              Size,
+              Buffer
+              );
+    File->CurrentPos += (UINT32) Size;
+    return Status;
+
+  } else {
+
+    if ((File->Attributes & FAT_ATTR_DIRECTORY) == 0) {
+      Size = Size < (File->FileSize - File->CurrentPos) ? Size : (File->FileSize - File->CurrentPos);
+    }
+    //
+    // This is a normal cluster based file
+    //
+    while (Size != 0) {
+      DivU64x32Remainder (File->CurrentPos, File->Volume->ClusterSize, &Offset);
+      PhysicalAddr  = File->Volume->FirstClusterPos + MultU64x32 (File->Volume->ClusterSize, File->CurrentCluster - 2);
+
+      Amount        = File->StraightReadAmount;
+      Amount        = Size > Amount ? Amount : Size;
+      Status = FatReadDisk (
+                PrivateData,
+                File->Volume->BlockDeviceNo,
+                PhysicalAddr + Offset,
+                Amount,
+                BufferPtr
+                );
+      if (EFI_ERROR (Status)) {
+        return EFI_DEVICE_ERROR;
+      }
+      //
+      // Advance the file's current pos and current cluster
+      //
+      FatSetFilePos (PrivateData, File, (UINT32) Amount);
+
+      BufferPtr += Amount;
+      Size -= Amount;
+    }
+
+    return EFI_SUCCESS;
+  }
+}
+
+
+/**
+  This function reads the next item in the parent directory and
+  initializes the output parameter SubFile (CurrentPos is initialized to 0).
+  The function updates the CurrentPos of the parent dir to after the item read.
+  If no more items were found, the function returns EFI_NOT_FOUND.
+
+  @param  PrivateData            Global memory map for accessing global variables
+  @param  ParentDir              The parent directory.
+  @param  SubFile                The File structure containing the sub file that
+                                 is caught.
+
+  @retval EFI_SUCCESS            The next sub file is obtained.
+  @retval EFI_INVALID_PARAMETER  The ParentDir is not a directory.
+  @retval EFI_NOT_FOUND          No more sub file exists.
+  @retval EFI_DEVICE_ERROR       Something error while accessing media.
+
+**/
+EFI_STATUS
+FatReadNextDirectoryEntry (
+  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
+  IN  PEI_FAT_FILE          *ParentDir,
+  OUT PEI_FAT_FILE          *SubFile
+  )
+{
+  EFI_STATUS          Status;
+  FAT_DIRECTORY_ENTRY DirEntry;
+  CHAR16              *Pos;
+  CHAR16              BaseName[9];
+  CHAR16              Ext[4];
+
+  ZeroMem ((UINT8 *) SubFile, sizeof (PEI_FAT_FILE));
+
+  //
+  // Pick a valid directory entry
+  //
+  while (1) {
+    //
+    // Read one entry
+    //
+    Status = FatReadFile (PrivateData, ParentDir, 32, &DirEntry);
+    if (EFI_ERROR (Status)) {
+      return EFI_DEVICE_ERROR;
+    }
+    //
+    // We only search for *FILE* in root directory
+    // Long file name entry is *NOT* supported
+    //
+    if (((DirEntry.Attributes & FAT_ATTR_DIRECTORY) == FAT_ATTR_DIRECTORY) || (DirEntry.Attributes == FAT_ATTR_LFN)) {
+      continue;
+    }
+    //
+    // if this is a terminator dir entry, just return EFI_NOT_FOUND
+    //
+    if (DirEntry.FileName[0] == EMPTY_ENTRY_MARK) {
+      return EFI_NOT_FOUND;
+    }
+    //
+    // If this not an invalid entry neither an empty entry, this is what we want.
+    // otherwise we will start a new loop to continue to find something meaningful
+    //
+    if ((UINT8) DirEntry.FileName[0] != DELETE_ENTRY_MARK) {
+      break;
+    }
+  }
+  //
+  // fill in the output parameter
+  //
+  EngFatToStr (8, DirEntry.FileName, BaseName);
+  EngFatToStr (3, DirEntry.FileName + 8, Ext);
+
+  Pos = (UINT16 *) SubFile->FileName;
+  SetMem ((UINT8 *) Pos, FAT_MAX_FILE_NAME_LENGTH, 0);
+  CopyMem ((UINT8 *) Pos, (UINT8 *) BaseName, 2 * (StrLen (BaseName) + 1));
+
+  if (Ext[0] != 0) {
+    Pos += StrLen (BaseName);
+    *Pos = '.';
+    Pos++;
+    CopyMem ((UINT8 *) Pos, (UINT8 *) Ext, 2 * (StrLen (Ext) + 1));
+  }
+
+  SubFile->Attributes     = DirEntry.Attributes;
+  SubFile->CurrentCluster = DirEntry.FileCluster;
+  if (ParentDir->Volume->FatType == Fat32) {
+    SubFile->CurrentCluster |= DirEntry.FileClusterHigh << 16;
+  }
+
+  SubFile->CurrentPos       = 0;
+  SubFile->FileSize         = DirEntry.FileSize;
+  SubFile->StartingCluster  = SubFile->CurrentCluster;
+  SubFile->Volume           = ParentDir->Volume;
+
+  //
+  // in Pei phase, time parameters do not need to be filled for minimum use.
+  //
+  return Status;
+}
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/FatLiteApi.c b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/FatLiteApi.c
new file mode 100644
index 00000000..c2bb062f
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/FatLiteApi.c
@@ -0,0 +1,675 @@
+/** @file
+  FAT recovery PEIM entry point, Ppi Functions and FAT Api functions.
+
+Copyright (c) 2006 - 2019, Intel Corporation. All rights reserved.<BR>
+
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "FatLitePeim.h"
+
+PEI_FAT_PRIVATE_DATA  *mPrivateData = NULL;
+
+/**
+  BlockIo installation notification function. Find out all the current BlockIO
+  PPIs in the system and add them into private data. Assume there is
+
+  @param  PeiServices             General purpose services available to every
+                                  PEIM.
+  @param  NotifyDescriptor        The typedef structure of the notification
+                                  descriptor. Not used in this function.
+  @param  Ppi                     The typedef structure of the PPI descriptor.
+                                  Not used in this function.
+
+  @retval EFI_SUCCESS             The function completed successfully.
+
+**/
+EFI_STATUS
+EFIAPI
+BlockIoNotifyEntry (
+  IN EFI_PEI_SERVICES           **PeiServices,
+  IN EFI_PEI_NOTIFY_DESCRIPTOR  *NotifyDescriptor,
+  IN VOID                       *Ppi
+  );
+
+
+/**
+  Discover all the block I/O devices to find the FAT volume.
+
+  @param  PrivateData             Global memory map for accessing global
+                                  variables.
+  @param  BlockIo2                Boolean to show whether using BlockIo2 or BlockIo
+
+  @retval EFI_SUCCESS             The function completed successfully.
+
+**/
+EFI_STATUS
+UpdateBlocksAndVolumes (
+  IN OUT PEI_FAT_PRIVATE_DATA            *PrivateData,
+  IN     BOOLEAN                         BlockIo2
+  )
+{
+  EFI_STATUS                     Status;
+  EFI_PEI_PPI_DESCRIPTOR         *TempPpiDescriptor;
+  UINTN                          BlockIoPpiInstance;
+  EFI_PEI_RECOVERY_BLOCK_IO_PPI  *BlockIoPpi;
+  EFI_PEI_RECOVERY_BLOCK_IO2_PPI *BlockIo2Ppi;
+  UINTN                          NumberBlockDevices;
+  UINTN                          Index;
+  EFI_PEI_BLOCK_IO_MEDIA         Media;
+  EFI_PEI_BLOCK_IO2_MEDIA        Media2;
+  PEI_FAT_VOLUME                 Volume;
+  EFI_PEI_SERVICES               **PeiServices;
+
+  PeiServices = (EFI_PEI_SERVICES **) GetPeiServicesTablePointer ();
+  BlockIo2Ppi = NULL;
+  BlockIoPpi  = NULL;
+  //
+  // Clean up caches
+  //
+  for (Index = 0; Index < PEI_FAT_CACHE_SIZE; Index++) {
+    PrivateData->CacheBuffer[Index].Valid = FALSE;
+  }
+
+  PrivateData->BlockDeviceCount = 0;
+
+  //
+  // Find out all Block Io Ppi instances within the system
+  // Assuming all device Block Io Peims are dispatched already
+  //
+  for (BlockIoPpiInstance = 0; BlockIoPpiInstance < PEI_FAT_MAX_BLOCK_IO_PPI; BlockIoPpiInstance++) {
+    if (BlockIo2) {
+      Status = PeiServicesLocatePpi (
+                &gEfiPeiVirtualBlockIo2PpiGuid,
+                BlockIoPpiInstance,
+                &TempPpiDescriptor,
+                (VOID **) &BlockIo2Ppi
+                );
+    } else {
+      Status = PeiServicesLocatePpi (
+                &gEfiPeiVirtualBlockIoPpiGuid,
+                BlockIoPpiInstance,
+                &TempPpiDescriptor,
+                (VOID **) &BlockIoPpi
+                );
+    }
+    if (EFI_ERROR (Status)) {
+      //
+      // Done with all Block Io Ppis
+      //
+      break;
+    }
+
+    if (BlockIo2) {
+      Status = BlockIo2Ppi->GetNumberOfBlockDevices (
+                              PeiServices,
+                              BlockIo2Ppi,
+                              &NumberBlockDevices
+                              );
+    } else {
+      Status = BlockIoPpi->GetNumberOfBlockDevices (
+                             PeiServices,
+                             BlockIoPpi,
+                             &NumberBlockDevices
+                             );
+    }
+    if (EFI_ERROR (Status)) {
+      continue;
+    }
+
+    for (Index = 1; Index <= NumberBlockDevices && PrivateData->BlockDeviceCount < PEI_FAT_MAX_BLOCK_DEVICE; Index++) {
+
+      if (BlockIo2) {
+        Status = BlockIo2Ppi->GetBlockDeviceMediaInfo (
+                                PeiServices,
+                                BlockIo2Ppi,
+                                Index,
+                                &Media2
+                                );
+        if (EFI_ERROR (Status) || !Media2.MediaPresent) {
+          continue;
+        }
+        PrivateData->BlockDevice[PrivateData->BlockDeviceCount].BlockIo2        = BlockIo2Ppi;
+        PrivateData->BlockDevice[PrivateData->BlockDeviceCount].InterfaceType   = Media2.InterfaceType;
+        PrivateData->BlockDevice[PrivateData->BlockDeviceCount].LastBlock       = Media2.LastBlock;
+        PrivateData->BlockDevice[PrivateData->BlockDeviceCount].BlockSize       = Media2.BlockSize;
+      } else {
+        Status = BlockIoPpi->GetBlockDeviceMediaInfo (
+                               PeiServices,
+                               BlockIoPpi,
+                               Index,
+                               &Media
+                               );
+        if (EFI_ERROR (Status) || !Media.MediaPresent) {
+          continue;
+        }
+        PrivateData->BlockDevice[PrivateData->BlockDeviceCount].BlockIo    = BlockIoPpi;
+        PrivateData->BlockDevice[PrivateData->BlockDeviceCount].DevType    = Media.DeviceType;
+        PrivateData->BlockDevice[PrivateData->BlockDeviceCount].LastBlock  = Media.LastBlock;
+        PrivateData->BlockDevice[PrivateData->BlockDeviceCount].BlockSize  = (UINT32) Media.BlockSize;
+      }
+
+      PrivateData->BlockDevice[PrivateData->BlockDeviceCount].IoAlign = 0;
+      //
+      // Not used here
+      //
+      PrivateData->BlockDevice[PrivateData->BlockDeviceCount].Logical           = FALSE;
+      PrivateData->BlockDevice[PrivateData->BlockDeviceCount].PartitionChecked  = FALSE;
+
+      PrivateData->BlockDevice[PrivateData->BlockDeviceCount].PhysicalDevNo     = (UINT8) Index;
+      PrivateData->BlockDeviceCount++;
+    }
+  }
+  //
+  // Find out all logical devices
+  //
+  FatFindPartitions (PrivateData);
+
+  //
+  // Build up file system volume array
+  //
+  PrivateData->VolumeCount = 0;
+  for (Index = 0; Index < PrivateData->BlockDeviceCount; Index++) {
+    Volume.BlockDeviceNo  = Index;
+    Status                = FatGetBpbInfo (PrivateData, &Volume);
+    if (Status == EFI_SUCCESS) {
+      //
+      // Add the detected volume to the volume array
+      //
+      CopyMem (
+        (UINT8 *) &(PrivateData->Volume[PrivateData->VolumeCount]),
+        (UINT8 *) &Volume,
+        sizeof (PEI_FAT_VOLUME)
+        );
+      PrivateData->VolumeCount += 1;
+      if (PrivateData->VolumeCount >= PEI_FAT_MAX_VOLUME) {
+        break;
+      }
+    }
+  }
+
+  return EFI_SUCCESS;
+}
+
+
+/**
+  BlockIo installation notification function. Find out all the current BlockIO
+  PPIs in the system and add them into private data. Assume there is
+
+  @param  PeiServices             General purpose services available to every
+                                  PEIM.
+  @param  NotifyDescriptor        The typedef structure of the notification
+                                  descriptor. Not used in this function.
+  @param  Ppi                     The typedef structure of the PPI descriptor.
+                                  Not used in this function.
+
+  @retval EFI_SUCCESS             The function completed successfully.
+
+**/
+EFI_STATUS
+EFIAPI
+BlockIoNotifyEntry (
+  IN EFI_PEI_SERVICES           **PeiServices,
+  IN EFI_PEI_NOTIFY_DESCRIPTOR  *NotifyDescriptor,
+  IN VOID                       *Ppi
+  )
+{
+  if (CompareGuid (NotifyDescriptor->Guid, &gEfiPeiVirtualBlockIo2PpiGuid)) {
+    UpdateBlocksAndVolumes (mPrivateData, TRUE);
+  } else {
+    UpdateBlocksAndVolumes (mPrivateData, FALSE);
+  }
+  return EFI_SUCCESS;
+}
+
+
+/**
+  Installs the Device Recovery Module PPI, Initialize BlockIo Ppi
+  installation notification
+
+  @param  FileHandle              Handle of the file being invoked. Type
+                                  EFI_PEI_FILE_HANDLE is defined in
+                                  FfsFindNextFile().
+  @param  PeiServices             Describes the list of possible PEI Services.
+
+  @retval EFI_SUCCESS             The entry point was executed successfully.
+  @retval EFI_OUT_OF_RESOURCES    There is no enough memory to complete the
+                                  operations.
+
+**/
+EFI_STATUS
+EFIAPI
+FatPeimEntry (
+  IN EFI_PEI_FILE_HANDLE       FileHandle,
+  IN CONST EFI_PEI_SERVICES    **PeiServices
+  )
+{
+  EFI_STATUS            Status;
+  EFI_PHYSICAL_ADDRESS  Address;
+  PEI_FAT_PRIVATE_DATA  *PrivateData;
+
+  Status = PeiServicesRegisterForShadow (FileHandle);
+  if (!EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  Status = PeiServicesAllocatePages (
+            EfiBootServicesCode,
+            (sizeof (PEI_FAT_PRIVATE_DATA) - 1) / PEI_FAT_MEMORY_PAGE_SIZE + 1,
+            &Address
+            );
+  if (EFI_ERROR (Status)) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  PrivateData = (PEI_FAT_PRIVATE_DATA *) (UINTN) Address;
+
+  //
+  // Initialize Private Data (to zero, as is required by subsequent operations)
+  //
+  ZeroMem ((UINT8 *) PrivateData, sizeof (PEI_FAT_PRIVATE_DATA));
+
+  PrivateData->Signature = PEI_FAT_PRIVATE_DATA_SIGNATURE;
+
+  //
+  // Installs Ppi
+  //
+  PrivateData->DeviceRecoveryPpi.GetNumberRecoveryCapsules  = GetNumberRecoveryCapsules;
+  PrivateData->DeviceRecoveryPpi.GetRecoveryCapsuleInfo     = GetRecoveryCapsuleInfo;
+  PrivateData->DeviceRecoveryPpi.LoadRecoveryCapsule        = LoadRecoveryCapsule;
+
+  PrivateData->PpiDescriptor.Flags                          = (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST);
+  PrivateData->PpiDescriptor.Guid = &gEfiPeiDeviceRecoveryModulePpiGuid;
+  PrivateData->PpiDescriptor.Ppi  = &PrivateData->DeviceRecoveryPpi;
+
+  Status = PeiServicesInstallPpi (&PrivateData->PpiDescriptor);
+  if (EFI_ERROR (Status)) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+  //
+  // Other initializations
+  //
+  PrivateData->BlockDeviceCount = 0;
+
+  UpdateBlocksAndVolumes (PrivateData, TRUE);
+  UpdateBlocksAndVolumes (PrivateData, FALSE);
+
+  //
+  // PrivateData is allocated now, set it to the module variable
+  //
+  mPrivateData = PrivateData;
+
+  //
+  // Installs Block Io Ppi notification function
+  //
+  PrivateData->NotifyDescriptor[0].Flags =
+    (
+      EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK
+    );
+  PrivateData->NotifyDescriptor[0].Guid    = &gEfiPeiVirtualBlockIoPpiGuid;
+  PrivateData->NotifyDescriptor[0].Notify  = BlockIoNotifyEntry;
+  PrivateData->NotifyDescriptor[1].Flags  =
+    (
+      EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK |
+      EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST
+    );
+  PrivateData->NotifyDescriptor[1].Guid    = &gEfiPeiVirtualBlockIo2PpiGuid;
+  PrivateData->NotifyDescriptor[1].Notify  = BlockIoNotifyEntry;
+  return PeiServicesNotifyPpi (&PrivateData->NotifyDescriptor[0]);
+}
+
+
+/**
+  Returns the number of DXE capsules residing on the device.
+
+  This function searches for DXE capsules from the associated device and returns
+  the number and maximum size in bytes of the capsules discovered. Entry 1 is
+  assumed to be the highest load priority and entry N is assumed to be the lowest
+  priority.
+
+  @param[in]  PeiServices              General-purpose services that are available
+                                       to every PEIM
+  @param[in]  This                     Indicates the EFI_PEI_DEVICE_RECOVERY_MODULE_PPI
+                                       instance.
+  @param[out] NumberRecoveryCapsules   Pointer to a caller-allocated UINTN. On
+                                       output, *NumberRecoveryCapsules contains
+                                       the number of recovery capsule images
+                                       available for retrieval from this PEIM
+                                       instance.
+
+  @retval EFI_SUCCESS        One or more capsules were discovered.
+  @retval EFI_DEVICE_ERROR   A device error occurred.
+  @retval EFI_NOT_FOUND      A recovery DXE capsule cannot be found.
+
+**/
+EFI_STATUS
+EFIAPI
+GetNumberRecoveryCapsules (
+  IN EFI_PEI_SERVICES                               **PeiServices,
+  IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI             *This,
+  OUT UINTN                                         *NumberRecoveryCapsules
+  )
+{
+  EFI_STATUS            Status;
+  PEI_FAT_PRIVATE_DATA  *PrivateData;
+  UINTN                 Index;
+  UINTN                 RecoveryCapsuleCount;
+  PEI_FILE_HANDLE       Handle;
+
+  PrivateData = PEI_FAT_PRIVATE_DATA_FROM_THIS (This);
+
+  //
+  // Search each volume in the root directory for the Recovery capsule
+  //
+  RecoveryCapsuleCount = 0;
+  for (Index = 0; Index < PrivateData->VolumeCount; Index++) {
+    Status = FindRecoveryFile (PrivateData, Index, (CHAR16 *)PcdGetPtr(PcdRecoveryFileName), &Handle);
+    if (EFI_ERROR (Status)) {
+      continue;
+    }
+
+    RecoveryCapsuleCount++;
+  }
+
+  *NumberRecoveryCapsules = RecoveryCapsuleCount;
+
+  if (*NumberRecoveryCapsules == 0) {
+    return EFI_NOT_FOUND;
+  }
+
+  return EFI_SUCCESS;
+}
+
+
+/**
+  Returns the size and type of the requested recovery capsule.
+
+  This function gets the size and type of the capsule specified by CapsuleInstance.
+
+  @param[in]  PeiServices       General-purpose services that are available to every PEIM
+  @param[in]  This              Indicates the EFI_PEI_DEVICE_RECOVERY_MODULE_PPI
+                                instance.
+  @param[in]  CapsuleInstance   Specifies for which capsule instance to retrieve
+                                the information.  This parameter must be between
+                                one and the value returned by GetNumberRecoveryCapsules()
+                                in NumberRecoveryCapsules.
+  @param[out] Size              A pointer to a caller-allocated UINTN in which
+                                the size of the requested recovery module is
+                                returned.
+  @param[out] CapsuleType       A pointer to a caller-allocated EFI_GUID in which
+                                the type of the requested recovery capsule is
+                                returned.  The semantic meaning of the value
+                                returned is defined by the implementation.
+
+  @retval EFI_SUCCESS        One or more capsules were discovered.
+  @retval EFI_DEVICE_ERROR   A device error occurred.
+  @retval EFI_NOT_FOUND      A recovery DXE capsule cannot be found.
+
+**/
+EFI_STATUS
+EFIAPI
+GetRecoveryCapsuleInfo (
+  IN  EFI_PEI_SERVICES                              **PeiServices,
+  IN  EFI_PEI_DEVICE_RECOVERY_MODULE_PPI            *This,
+  IN  UINTN                                         CapsuleInstance,
+  OUT UINTN                                         *Size,
+  OUT EFI_GUID                                      *CapsuleType
+  )
+{
+  EFI_STATUS            Status;
+  PEI_FAT_PRIVATE_DATA  *PrivateData;
+  UINTN                 Index;
+  UINTN                 BlockDeviceNo;
+  UINTN                 RecoveryCapsuleCount;
+  PEI_FILE_HANDLE       Handle;
+  UINTN                 NumberRecoveryCapsules;
+
+  Status = GetNumberRecoveryCapsules (PeiServices, This, &NumberRecoveryCapsules);
+
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  if ((CapsuleInstance == 0) || (CapsuleInstance > NumberRecoveryCapsules)) {
+    return EFI_NOT_FOUND;
+  }
+
+  PrivateData = PEI_FAT_PRIVATE_DATA_FROM_THIS (This);
+
+  //
+  // Search each volume in the root directory for the Recovery capsule
+  //
+  RecoveryCapsuleCount = 0;
+  for (Index = 0; Index < PrivateData->VolumeCount; Index++) {
+    Status = FindRecoveryFile (PrivateData, Index, (CHAR16 *)PcdGetPtr(PcdRecoveryFileName), &Handle);
+
+    if (EFI_ERROR (Status)) {
+      continue;
+    }
+
+    if (CapsuleInstance - 1 == RecoveryCapsuleCount) {
+      //
+      // Get file size
+      //
+      *Size = (UINTN) (((PEI_FAT_FILE *) Handle)->FileSize);
+
+      //
+      // Find corresponding physical block device
+      //
+      BlockDeviceNo = PrivateData->Volume[Index].BlockDeviceNo;
+      while (PrivateData->BlockDevice[BlockDeviceNo].Logical && BlockDeviceNo < PrivateData->BlockDeviceCount) {
+        BlockDeviceNo = PrivateData->BlockDevice[BlockDeviceNo].ParentDevNo;
+      }
+      //
+      // Fill in the Capsule Type GUID according to the block device type
+      //
+      if (BlockDeviceNo < PrivateData->BlockDeviceCount) {
+        if (PrivateData->BlockDevice[BlockDeviceNo].BlockIo2 != NULL) {
+          switch (PrivateData->BlockDevice[BlockDeviceNo].InterfaceType) {
+          case MSG_ATAPI_DP:
+            CopyGuid (CapsuleType, &gRecoveryOnFatIdeDiskGuid);
+            break;
+
+          case MSG_USB_DP:
+            CopyGuid (CapsuleType, &gRecoveryOnFatUsbDiskGuid);
+            break;
+
+          case MSG_NVME_NAMESPACE_DP:
+            CopyGuid (CapsuleType, &gRecoveryOnFatNvmeDiskGuid);
+            break;
+
+          default:
+            break;
+          }
+        }
+        if (PrivateData->BlockDevice[BlockDeviceNo].BlockIo != NULL) {
+          switch (PrivateData->BlockDevice[BlockDeviceNo].DevType) {
+          case LegacyFloppy:
+            CopyGuid (CapsuleType, &gRecoveryOnFatFloppyDiskGuid);
+            break;
+
+          case IdeCDROM:
+          case IdeLS120:
+            CopyGuid (CapsuleType, &gRecoveryOnFatIdeDiskGuid);
+            break;
+
+          case UsbMassStorage:
+            CopyGuid (CapsuleType, &gRecoveryOnFatUsbDiskGuid);
+            break;
+
+          default:
+            break;
+          }
+        }
+      }
+
+      return EFI_SUCCESS;
+    }
+
+    RecoveryCapsuleCount++;
+  }
+
+  return EFI_NOT_FOUND;
+}
+
+
+/**
+  Loads a DXE capsule from some media into memory.
+
+  This function, by whatever mechanism, retrieves a DXE capsule from some device
+  and loads it into memory. Note that the published interface is device neutral.
+
+  @param[in]     PeiServices       General-purpose services that are available
+                                   to every PEIM
+  @param[in]     This              Indicates the EFI_PEI_DEVICE_RECOVERY_MODULE_PPI
+                                   instance.
+  @param[in]     CapsuleInstance   Specifies which capsule instance to retrieve.
+  @param[out]    Buffer            Specifies a caller-allocated buffer in which
+                                   the requested recovery capsule will be returned.
+
+  @retval EFI_SUCCESS        The capsule was loaded correctly.
+  @retval EFI_DEVICE_ERROR   A device error occurred.
+  @retval EFI_NOT_FOUND      A requested recovery DXE capsule cannot be found.
+
+**/
+EFI_STATUS
+EFIAPI
+LoadRecoveryCapsule (
+  IN EFI_PEI_SERVICES                             **PeiServices,
+  IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI           *This,
+  IN UINTN                                        CapsuleInstance,
+  OUT VOID                                        *Buffer
+  )
+{
+  EFI_STATUS            Status;
+  PEI_FAT_PRIVATE_DATA  *PrivateData;
+  UINTN                 Index;
+  UINTN                 RecoveryCapsuleCount;
+  PEI_FILE_HANDLE       Handle;
+  UINTN                 NumberRecoveryCapsules;
+
+  Status = GetNumberRecoveryCapsules (PeiServices, This, &NumberRecoveryCapsules);
+
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  if ((CapsuleInstance == 0) || (CapsuleInstance > NumberRecoveryCapsules)) {
+    return EFI_NOT_FOUND;
+  }
+
+  PrivateData = PEI_FAT_PRIVATE_DATA_FROM_THIS (This);
+
+  //
+  // Search each volume in the root directory for the Recovery capsule
+  //
+  RecoveryCapsuleCount = 0;
+  for (Index = 0; Index < PrivateData->VolumeCount; Index++) {
+    Status = FindRecoveryFile (PrivateData, Index, (CHAR16 *)PcdGetPtr(PcdRecoveryFileName), &Handle);
+    if (EFI_ERROR (Status)) {
+      continue;
+    }
+
+    if (CapsuleInstance - 1 == RecoveryCapsuleCount) {
+
+      Status = FatReadFile (
+                PrivateData,
+                Handle,
+                (UINTN) (((PEI_FAT_FILE *) Handle)->FileSize),
+                Buffer
+                );
+      return Status;
+    }
+
+    RecoveryCapsuleCount++;
+  }
+
+  return EFI_NOT_FOUND;
+}
+
+
+/**
+  Finds the recovery file on a FAT volume.
+  This function finds the recovery file named FileName on a specified FAT volume and returns
+  its FileHandle pointer.
+
+  @param  PrivateData             Global memory map for accessing global
+                                  variables.
+  @param  VolumeIndex             The index of the volume.
+  @param  FileName                The recovery file name to find.
+  @param  Handle                  The output file handle.
+
+  @retval EFI_DEVICE_ERROR        Some error occurred when operating the FAT
+                                  volume.
+  @retval EFI_NOT_FOUND           The recovery file was not found.
+  @retval EFI_SUCCESS             The recovery file was successfully found on the
+                                  FAT volume.
+
+**/
+EFI_STATUS
+FindRecoveryFile (
+  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
+  IN  UINTN                 VolumeIndex,
+  IN  CHAR16                *FileName,
+  OUT PEI_FILE_HANDLE       *Handle
+  )
+{
+  EFI_STATUS    Status;
+  PEI_FAT_FILE  Parent;
+  PEI_FAT_FILE  *File;
+
+  File = &PrivateData->File;
+
+  //
+  // VolumeIndex must be less than PEI_FAT_MAX_VOLUME because PrivateData->VolumeCount
+  // cannot be larger than PEI_FAT_MAX_VOLUME when detecting recovery volume.
+  //
+  ASSERT (VolumeIndex < PEI_FAT_MAX_VOLUME);
+
+  //
+  // Construct root directory file
+  //
+  ZeroMem (&Parent, sizeof (PEI_FAT_FILE));
+  Parent.IsFixedRootDir   = (BOOLEAN) ((PrivateData->Volume[VolumeIndex].FatType == Fat32) ? FALSE : TRUE);
+  Parent.Attributes       = FAT_ATTR_DIRECTORY;
+  Parent.CurrentPos       = 0;
+  Parent.CurrentCluster   = Parent.IsFixedRootDir ? 0 : PrivateData->Volume[VolumeIndex].RootDirCluster;
+  Parent.StartingCluster  = Parent.CurrentCluster;
+  Parent.Volume           = &PrivateData->Volume[VolumeIndex];
+
+  Status                  = FatSetFilePos (PrivateData, &Parent, 0);
+  if (EFI_ERROR (Status)) {
+    return EFI_DEVICE_ERROR;
+  }
+  //
+  // Search for recovery capsule in root directory
+  //
+  Status = FatReadNextDirectoryEntry (PrivateData, &Parent, File);
+  while (Status == EFI_SUCCESS) {
+    //
+    // Compare whether the file name is recovery file name.
+    //
+    if (EngStriColl (PrivateData, FileName, File->FileName)) {
+      break;
+    }
+
+    Status = FatReadNextDirectoryEntry (PrivateData, &Parent, File);
+  }
+
+  if (EFI_ERROR (Status)) {
+    return EFI_NOT_FOUND;
+  }
+
+  //
+  // Get the recovery file, set its file position to 0.
+  //
+  if (File->StartingCluster != 0) {
+    Status = FatSetFilePos (PrivateData, File, 0);
+  }
+
+  *Handle = File;
+
+  return EFI_SUCCESS;
+
+}
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/FatLiteApi.h b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/FatLiteApi.h
new file mode 100644
index 00000000..712fa9d3
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/FatLiteApi.h
@@ -0,0 +1,25 @@
+/** @file
+  Definitions for FAT recovery PEIM API functions
+
+Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#ifndef _FAT_API_H_
+#define _FAT_API_H_
+
+//
+// API data structures
+//
+typedef VOID  *PEI_FILE_HANDLE;
+
+typedef enum {
+  Fat12,
+  Fat16,
+  Fat32,
+  FatUnknown
+} PEI_FAT_TYPE;
+
+#endif
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/FatLiteFmt.h b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/FatLiteFmt.h
new file mode 100644
index 00000000..37ea6404
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/FatLiteFmt.h
@@ -0,0 +1,138 @@
+/** @file
+  FAT format data structures
+
+Copyright (c) 2006 - 2017, Intel Corporation. All rights reserved.<BR>
+
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#ifndef _FAT_FMT_H_
+#define _FAT_FMT_H_
+
+//
+// Definitions
+//
+#define FAT_ATTR_READ_ONLY                0x01
+#define FAT_ATTR_HIDDEN                   0x02
+#define FAT_ATTR_SYSTEM                   0x04
+#define FAT_ATTR_VOLUME_ID                0x08
+#define FAT_ATTR_DIRECTORY                0x10
+#define FAT_ATTR_ARCHIVE                  0x20
+#define FAT_ATTR_LFN                      (FAT_ATTR_READ_ONLY | FAT_ATTR_HIDDEN | FAT_ATTR_SYSTEM | FAT_ATTR_VOLUME_ID)
+
+#define FAT_CLUSTER_SPECIAL               ((MAX_UINT32 &~0xF) | 0x7)
+#define FAT_CLUSTER_FREE                  0
+#define FAT_CLUSTER_RESERVED              (FAT_CLUSTER_SPECIAL)
+#define FAT_CLUSTER_BAD                   (FAT_CLUSTER_SPECIAL)
+#define FAT_CLUSTER_LAST                  (-1)
+
+#define DELETE_ENTRY_MARK                 0xE5
+#define EMPTY_ENTRY_MARK                  0x00
+
+#define FAT_CLUSTER_FUNCTIONAL(Cluster)   (((Cluster) == 0) || ((Cluster) >= FAT_CLUSTER_SPECIAL))
+#define FAT_CLUSTER_END_OF_CHAIN(Cluster) ((Cluster) > (FAT_CLUSTER_SPECIAL))
+
+//
+// Directory Entry
+//
+#pragma pack(1)
+
+typedef struct {
+  UINT16  Day : 5;
+  UINT16  Month : 4;
+  UINT16  Year : 7;                 // From 1980
+} FAT_DATE;
+
+typedef struct {
+  UINT16  DoubleSecond : 5;
+  UINT16  Minute : 6;
+  UINT16  Hour : 5;
+} FAT_TIME;
+
+typedef struct {
+  FAT_TIME  Time;
+  FAT_DATE  Date;
+} FAT_DATE_TIME;
+
+typedef struct {
+  CHAR8         FileName[11];       // 8.3 filename
+  UINT8         Attributes;
+  UINT8         CaseFlag;
+  UINT8         CreateMillisecond;  // (creation milliseconds - ignored)
+  FAT_DATE_TIME FileCreateTime;
+  FAT_DATE      FileLastAccess;
+  UINT16        FileClusterHigh;    // >= FAT32
+  FAT_DATE_TIME FileModificationTime;
+  UINT16        FileCluster;
+  UINT32        FileSize;
+} FAT_DIRECTORY_ENTRY;
+
+#pragma pack()
+//
+// Boot Sector
+//
+#pragma pack(1)
+
+typedef struct {
+
+  UINT8   Ia32Jump[3];
+  CHAR8   OemId[8];
+
+  UINT16  SectorSize;
+  UINT8   SectorsPerCluster;
+  UINT16  ReservedSectors;
+  UINT8   NoFats;
+  UINT16  RootEntries;          // < FAT32, root dir is fixed size
+  UINT16  Sectors;
+  UINT8   Media;                // (ignored)
+  UINT16  SectorsPerFat;        // < FAT32
+  UINT16  SectorsPerTrack;      // (ignored)
+  UINT16  Heads;                // (ignored)
+  UINT32  HiddenSectors;        // (ignored)
+  UINT32  LargeSectors;         // => FAT32
+  UINT8   PhysicalDriveNumber;  // (ignored)
+  UINT8   CurrentHead;          // holds boot_sector_dirty bit
+  UINT8   Signature;            // (ignored)
+  CHAR8   Id[4];
+  CHAR8   FatLabel[11];
+  CHAR8   SystemId[8];
+
+} PEI_FAT_BOOT_SECTOR;
+
+typedef struct {
+
+  UINT8   Ia32Jump[3];
+  CHAR8   OemId[8];
+
+  UINT16  SectorSize;
+  UINT8   SectorsPerCluster;
+  UINT16  ReservedSectors;
+  UINT8   NoFats;
+  UINT16  RootEntries;          // < FAT32, root dir is fixed size
+  UINT16  Sectors;
+  UINT8   Media;                // (ignored)
+  UINT16  SectorsPerFat;        // < FAT32
+  UINT16  SectorsPerTrack;      // (ignored)
+  UINT16  Heads;                // (ignored)
+  UINT32  HiddenSectors;        // (ignored)
+  UINT32  LargeSectors;         // Used if Sectors==0
+  UINT32  LargeSectorsPerFat;   // FAT32
+  UINT16  ExtendedFlags;        // FAT32 (ignored)
+  UINT16  FsVersion;            // FAT32 (ignored)
+  UINT32  RootDirFirstCluster;  // FAT32
+  UINT16  FsInfoSector;         // FAT32
+  UINT16  BackupBootSector;     // FAT32
+  UINT8   Reserved[12];         // FAT32 (ignored)
+  UINT8   PhysicalDriveNumber;  // (ignored)
+  UINT8   CurrentHead;          // holds boot_sector_dirty bit
+  UINT8   Signature;            // (ignored)
+  CHAR8   Id[4];
+  CHAR8   FatLabel[11];
+  CHAR8   SystemId[8];
+
+} PEI_FAT_BOOT_SECTOR_EX;
+
+#pragma pack()
+
+#endif
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/FatLiteLib.c b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/FatLiteLib.c
new file mode 100644
index 00000000..2b114391
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/FatLiteLib.c
@@ -0,0 +1,370 @@
+/** @file
+  General purpose supporting routines for FAT recovery PEIM
+
+Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>
+
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "FatLitePeim.h"
+
+
+#define CHAR_FAT_VALID  0x01
+
+
+/**
+  Converts a union code character to upper case.
+  This functions converts a unicode character to upper case.
+  If the input Letter is not a lower-cased letter,
+  the original value is returned.
+
+  @param  Letter            The input unicode character.
+
+  @return The upper cased letter.
+
+**/
+CHAR16
+ToUpper (
+  IN CHAR16                    Letter
+  )
+{
+  if ('a' <= Letter && Letter <= 'z') {
+    Letter = (CHAR16) (Letter - 0x20);
+  }
+
+  return Letter;
+}
+
+
+/**
+  Reads a block of data from the block device by calling
+  underlying Block I/O service.
+
+  @param  PrivateData       Global memory map for accessing global variables
+  @param  BlockDeviceNo     The index for the block device number.
+  @param  Lba               The logic block address to read data from.
+  @param  BufferSize        The size of data in byte to read.
+  @param  Buffer            The buffer of the
+
+  @retval EFI_DEVICE_ERROR  The specified block device number exceeds the maximum
+                            device number.
+  @retval EFI_DEVICE_ERROR  The maximum address has exceeded the maximum address
+                            of the block device.
+
+**/
+EFI_STATUS
+FatReadBlock (
+  IN  PEI_FAT_PRIVATE_DATA   *PrivateData,
+  IN  UINTN                  BlockDeviceNo,
+  IN  EFI_PEI_LBA            Lba,
+  IN  UINTN                  BufferSize,
+  OUT VOID                   *Buffer
+  )
+{
+  EFI_STATUS            Status;
+  PEI_FAT_BLOCK_DEVICE  *BlockDev;
+
+  if (BlockDeviceNo > PEI_FAT_MAX_BLOCK_DEVICE - 1) {
+    return EFI_DEVICE_ERROR;
+  }
+
+  Status    = EFI_SUCCESS;
+  BlockDev  = &(PrivateData->BlockDevice[BlockDeviceNo]);
+
+  if (BufferSize > MultU64x32 (BlockDev->LastBlock - Lba + 1, BlockDev->BlockSize)) {
+    return EFI_DEVICE_ERROR;
+  }
+
+  if (!BlockDev->Logical) {
+    //
+    // Status = BlockDev->ReadFunc
+    //  (PrivateData->PeiServices, BlockDev->PhysicalDevNo, Lba, BufferSize, Buffer);
+    //
+    if (BlockDev->BlockIo2 != NULL) {
+      Status = BlockDev->BlockIo2->ReadBlocks (
+                                    (EFI_PEI_SERVICES **) GetPeiServicesTablePointer (),
+                                    BlockDev->BlockIo2,
+                                    BlockDev->PhysicalDevNo,
+                                    Lba,
+                                    BufferSize,
+                                    Buffer
+                                    );
+    } else {
+      Status = BlockDev->BlockIo->ReadBlocks (
+                                  (EFI_PEI_SERVICES **) GetPeiServicesTablePointer (),
+                                  BlockDev->BlockIo,
+                                  BlockDev->PhysicalDevNo,
+                                  Lba,
+                                  BufferSize,
+                                  Buffer
+                                  );
+    }
+
+  } else {
+    Status = FatReadDisk (
+              PrivateData,
+              BlockDev->ParentDevNo,
+              BlockDev->StartingPos + MultU64x32 (Lba, BlockDev->BlockSize),
+              BufferSize,
+              Buffer
+              );
+  }
+
+  return Status;
+}
+
+
+/**
+  Find a cache block designated to specific Block device and Lba.
+  If not found, invalidate an oldest one and use it. (LRU cache)
+
+  @param  PrivateData       the global memory map.
+  @param  BlockDeviceNo     the Block device.
+  @param  Lba               the Logical Block Address
+  @param  CachePtr          Ptr to the starting address of the memory holding the
+                            data;
+
+  @retval EFI_SUCCESS       The function completed successfully.
+  @retval EFI_DEVICE_ERROR  Something error while accessing media.
+
+**/
+EFI_STATUS
+FatGetCacheBlock (
+  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
+  IN  UINTN                 BlockDeviceNo,
+  IN  UINT64                Lba,
+  OUT CHAR8                 **CachePtr
+  )
+{
+  EFI_STATUS            Status;
+  PEI_FAT_CACHE_BUFFER  *CacheBuffer;
+  INTN                  Index;
+  STATIC UINT8          Seed;
+
+  Status      = EFI_SUCCESS;
+  CacheBuffer = NULL;
+
+  //
+  // go through existing cache buffers
+  //
+  for (Index = 0; Index < PEI_FAT_CACHE_SIZE; Index++) {
+    CacheBuffer = &(PrivateData->CacheBuffer[Index]);
+    if (CacheBuffer->Valid && CacheBuffer->BlockDeviceNo == BlockDeviceNo && CacheBuffer->Lba == Lba) {
+      break;
+    }
+  }
+
+  if (Index < PEI_FAT_CACHE_SIZE) {
+    *CachePtr = (CHAR8 *) CacheBuffer->Buffer;
+    return EFI_SUCCESS;
+  }
+  //
+  // We have to find an invalid cache buffer
+  //
+  for (Index = 0; Index < PEI_FAT_CACHE_SIZE; Index++) {
+    if (!PrivateData->CacheBuffer[Index].Valid) {
+      break;
+    }
+  }
+  //
+  // Use the cache buffer
+  //
+  if (Index == PEI_FAT_CACHE_SIZE) {
+    Index = (Seed++) % PEI_FAT_CACHE_SIZE;
+  }
+
+  //
+  // Current device ID should be less than maximum device ID.
+  //
+  if (BlockDeviceNo >= PEI_FAT_MAX_BLOCK_DEVICE) {
+    return EFI_DEVICE_ERROR;
+  }
+
+  CacheBuffer                 = &(PrivateData->CacheBuffer[Index]);
+
+  CacheBuffer->BlockDeviceNo  = BlockDeviceNo;
+  CacheBuffer->Lba            = Lba;
+  CacheBuffer->Size           = PrivateData->BlockDevice[BlockDeviceNo].BlockSize;
+
+  //
+  // Read in the data
+  //
+  Status = FatReadBlock (
+            PrivateData,
+            BlockDeviceNo,
+            Lba,
+            CacheBuffer->Size,
+            CacheBuffer->Buffer
+            );
+  if (EFI_ERROR (Status)) {
+    return EFI_DEVICE_ERROR;
+  }
+
+  CacheBuffer->Valid  = TRUE;
+  *CachePtr           = (CHAR8 *) CacheBuffer->Buffer;
+
+  return Status;
+}
+
+
+/**
+  Disk reading.
+
+  @param  PrivateData       the global memory map;
+  @param  BlockDeviceNo     the block device to read;
+  @param  StartingAddress   the starting address.
+  @param  Size              the amount of data to read.
+  @param  Buffer            the buffer holding the data
+
+  @retval EFI_SUCCESS       The function completed successfully.
+  @retval EFI_DEVICE_ERROR  Something error.
+
+**/
+EFI_STATUS
+FatReadDisk (
+  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
+  IN  UINTN                 BlockDeviceNo,
+  IN  UINT64                StartingAddress,
+  IN  UINTN                 Size,
+  OUT VOID                  *Buffer
+  )
+{
+  EFI_STATUS  Status;
+  UINT32      BlockSize;
+  CHAR8       *BufferPtr;
+  CHAR8       *CachePtr;
+  UINT32      Offset;
+  UINT64      Lba;
+  UINT64      OverRunLba;
+  UINTN       Amount;
+
+  Status    = EFI_SUCCESS;
+  BufferPtr = Buffer;
+  BlockSize = PrivateData->BlockDevice[BlockDeviceNo].BlockSize;
+
+  //
+  // Read underrun
+  //
+  Lba     = DivU64x32Remainder (StartingAddress, BlockSize, &Offset);
+  Status  = FatGetCacheBlock (PrivateData, BlockDeviceNo, Lba, &CachePtr);
+  if (EFI_ERROR (Status)) {
+    return EFI_DEVICE_ERROR;
+  }
+
+  Amount = Size < (BlockSize - Offset) ? Size : (BlockSize - Offset);
+  CopyMem (BufferPtr, CachePtr + Offset, Amount);
+
+  if (Size == Amount) {
+    return EFI_SUCCESS;
+  }
+
+  Size -= Amount;
+  BufferPtr += Amount;
+  StartingAddress += Amount;
+  Lba += 1;
+
+  //
+  // Read aligned parts
+  //
+  OverRunLba = Lba + DivU64x32Remainder (Size, BlockSize, &Offset);
+
+  Size -= Offset;
+  Status = FatReadBlock (PrivateData, BlockDeviceNo, Lba, Size, BufferPtr);
+  if (EFI_ERROR (Status)) {
+    return EFI_DEVICE_ERROR;
+  }
+
+  BufferPtr += Size;
+
+  //
+  // Read overrun
+  //
+  if (Offset != 0) {
+    Status = FatGetCacheBlock (PrivateData, BlockDeviceNo, OverRunLba, &CachePtr);
+    if (EFI_ERROR (Status)) {
+      return EFI_DEVICE_ERROR;
+    }
+
+    CopyMem (BufferPtr, CachePtr, Offset);
+  }
+
+  return Status;
+}
+
+
+/**
+  This version is different from the version in Unicode collation
+  protocol in that this version strips off trailing blanks.
+  Converts an 8.3 FAT file name using an OEM character set
+  to a Null-terminated Unicode string.
+  Here does not expand DBCS FAT chars.
+
+  @param  FatSize           The size of the string Fat in bytes.
+  @param  Fat               A pointer to a Null-terminated string that contains
+                            an 8.3 file name using an OEM character set.
+  @param  Str               A pointer to a Null-terminated Unicode string. The
+                            string must be allocated in advance to hold FatSize
+                            Unicode characters
+
+**/
+VOID
+EngFatToStr (
+  IN UINTN                            FatSize,
+  IN CHAR8                            *Fat,
+  OUT CHAR16                          *Str
+  )
+{
+  CHAR16  *String;
+
+  String = Str;
+  //
+  // No DBCS issues, just expand and add null terminate to end of string
+  //
+  while (*Fat != 0 && FatSize != 0) {
+    if (*Fat == ' ') {
+      break;
+    }
+    *String = *Fat;
+    String += 1;
+    Fat += 1;
+    FatSize -= 1;
+  }
+
+  *String = 0;
+}
+
+
+/**
+  Performs a case-insensitive comparison of two Null-terminated Unicode strings.
+
+  @param  PrivateData       Global memory map for accessing global variables
+  @param  Str1              First string to perform case insensitive comparison.
+  @param  Str2              Second string to perform case insensitive comparison.
+
+**/
+BOOLEAN
+EngStriColl (
+  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
+  IN CHAR16                 *Str1,
+  IN CHAR16                 *Str2
+  )
+{
+  CHAR16  UpperS1;
+  CHAR16  UpperS2;
+
+  UpperS1 = ToUpper (*Str1);
+  UpperS2 = ToUpper (*Str2);
+  while (*Str1 != 0) {
+    if (UpperS1 != UpperS2) {
+      return FALSE;
+    }
+
+    Str1++;
+    Str2++;
+    UpperS1 = ToUpper (*Str1);
+    UpperS2 = ToUpper (*Str2);
+  }
+
+  return (BOOLEAN) ((*Str2 != 0) ? FALSE : TRUE);
+}
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/FatLitePeim.h b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/FatLitePeim.h
new file mode 100644
index 00000000..0087123c
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/FatLitePeim.h
@@ -0,0 +1,522 @@
+/** @file
+  Data structures for FAT recovery PEIM
+
+Copyright (c) 2006 - 2019, Intel Corporation. All rights reserved.<BR>
+
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#ifndef _FAT_PEIM_H_
+#define _FAT_PEIM_H_
+
+#include <PiPei.h>
+
+#include <Guid/RecoveryDevice.h>
+#include <Ppi/BlockIo.h>
+#include <Ppi/BlockIo2.h>
+#include <Ppi/DeviceRecoveryModule.h>
+
+#include <Library/DebugLib.h>
+#include <Library/BaseLib.h>
+#include <Library/PeimEntryPoint.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/PcdLib.h>
+#include <Library/PeiServicesTablePointerLib.h>
+#include <Library/PeiServicesLib.h>
+
+#include "FatLiteApi.h"
+#include "FatLiteFmt.h"
+
+//
+// Definitions
+//
+
+#define PEI_FAT_CACHE_SIZE                            4
+#define PEI_FAT_MAX_BLOCK_SIZE                        8192
+#define FAT_MAX_FILE_NAME_LENGTH                      128
+#define PEI_FAT_MAX_BLOCK_DEVICE                      64
+#define PEI_FAT_MAX_BLOCK_IO_PPI                      32
+#define PEI_FAT_MAX_VOLUME                            64
+
+#define PEI_FAT_MEMORY_PAGE_SIZE                      0x1000
+
+//
+// Data Structures
+//
+//
+// The block device
+//
+typedef struct {
+
+  UINT32                        BlockSize;
+  UINT64                        LastBlock;
+  UINT32                        IoAlign;
+  BOOLEAN                       Logical;
+  BOOLEAN                       PartitionChecked;
+
+  //
+  // Following fields only valid for logical device
+  //
+  CHAR8                         PartitionFlag[8];
+  UINT64                        StartingPos;
+  UINTN                         ParentDevNo;
+
+  //
+  // Following fields only valid for physical device
+  //
+  EFI_PEI_BLOCK_DEVICE_TYPE     DevType;
+  UINT8                         InterfaceType;
+  //
+  // EFI_PEI_READ_BLOCKS         ReadFunc;
+  //
+  EFI_PEI_RECOVERY_BLOCK_IO_PPI  *BlockIo;
+  EFI_PEI_RECOVERY_BLOCK_IO2_PPI *BlockIo2;
+  UINT8                          PhysicalDevNo;
+} PEI_FAT_BLOCK_DEVICE;
+
+//
+// the Volume structure
+//
+typedef struct {
+
+  UINTN         BlockDeviceNo;
+  UINTN         VolumeNo;
+  UINT64        VolumeSize;
+  UINTN         MaxCluster;
+  CHAR16        VolumeLabel[FAT_MAX_FILE_NAME_LENGTH];
+  PEI_FAT_TYPE  FatType;
+  UINT64        FatPos;
+  UINT32        SectorSize;
+  UINT32        ClusterSize;
+  UINT64        FirstClusterPos;
+  UINT64        RootDirPos;
+  UINT32        RootEntries;
+  UINT32        RootDirCluster;
+
+} PEI_FAT_VOLUME;
+
+//
+// File instance
+//
+typedef struct {
+
+  PEI_FAT_VOLUME  *Volume;
+  CHAR16          FileName[FAT_MAX_FILE_NAME_LENGTH];
+
+  BOOLEAN         IsFixedRootDir;
+
+  UINT32          StartingCluster;
+  UINT32          CurrentPos;
+  UINT32          StraightReadAmount;
+  UINT32          CurrentCluster;
+
+  UINT8           Attributes;
+  UINT32          FileSize;
+
+} PEI_FAT_FILE;
+
+//
+// Cache Buffer
+//
+typedef struct {
+
+  BOOLEAN Valid;
+  UINTN   BlockDeviceNo;
+  UINT64  Lba;
+  UINT32  Lru;
+  UINT64  Buffer[PEI_FAT_MAX_BLOCK_SIZE / 8];
+  UINTN   Size;
+
+} PEI_FAT_CACHE_BUFFER;
+
+//
+// Private Data.
+// This structure abstracts the whole memory usage in FAT PEIM.
+// The entry point routine will get a chunk of memory (by whatever
+// means) whose size is sizeof(PEI_FAT_PRIVATE_DATA), which is clean
+// in both 32 and 64 bit environment. The boundary of the memory chunk
+// should be 64bit aligned.
+//
+#define PEI_FAT_PRIVATE_DATA_SIGNATURE  SIGNATURE_32 ('p', 'f', 'a', 't')
+
+typedef struct {
+
+  UINTN                               Signature;
+  EFI_PEI_DEVICE_RECOVERY_MODULE_PPI  DeviceRecoveryPpi;
+  EFI_PEI_PPI_DESCRIPTOR              PpiDescriptor;
+  EFI_PEI_NOTIFY_DESCRIPTOR           NotifyDescriptor[2];
+
+  UINT8                               UnicodeCaseMap[0x300];
+  CHAR8                               *EngUpperMap;
+  CHAR8                               *EngLowerMap;
+  CHAR8                               *EngInfoMap;
+
+  UINT64                              BlockData[PEI_FAT_MAX_BLOCK_SIZE / 8];
+  UINTN                               BlockDeviceCount;
+  PEI_FAT_BLOCK_DEVICE                BlockDevice[PEI_FAT_MAX_BLOCK_DEVICE];
+  UINTN                               VolumeCount;
+  PEI_FAT_VOLUME                      Volume[PEI_FAT_MAX_VOLUME];
+  PEI_FAT_FILE                        File;
+  PEI_FAT_CACHE_BUFFER                CacheBuffer[PEI_FAT_CACHE_SIZE];
+
+} PEI_FAT_PRIVATE_DATA;
+
+#define PEI_FAT_PRIVATE_DATA_FROM_THIS(a) \
+  CR (a,  PEI_FAT_PRIVATE_DATA, DeviceRecoveryPpi, PEI_FAT_PRIVATE_DATA_SIGNATURE)
+
+//
+// Extract INT32 from char array
+//
+#define UNPACK_INT32(a) \
+  (INT32) ((((UINT8 *) a)[0] << 0) | (((UINT8 *) a)[1] << 8) | (((UINT8 *) a)[2] << 16) | (((UINT8 *) a)[3] << 24))
+
+//
+// Extract UINT32 from char array
+//
+#define UNPACK_UINT32(a) \
+  (UINT32) ((((UINT8 *) a)[0] << 0) | (((UINT8 *) a)[1] << 8) | (((UINT8 *) a)[2] << 16) | (((UINT8 *) a)[3] << 24))
+
+
+//
+// API functions
+//
+
+/**
+  Finds the recovery file on a FAT volume.
+  This function finds the recovery file named FileName on a specified FAT volume and returns
+  its FileHandle pointer.
+
+  @param  PrivateData             Global memory map for accessing global
+                                  variables.
+  @param  VolumeIndex             The index of the volume.
+  @param  FileName                The recovery file name to find.
+  @param  Handle                  The output file handle.
+
+  @retval EFI_DEVICE_ERROR        Some error occurred when operating the FAT
+                                  volume.
+  @retval EFI_NOT_FOUND           The recovery file was not found.
+  @retval EFI_SUCCESS             The recovery file was successfully found on the
+                                  FAT volume.
+
+**/
+EFI_STATUS
+FindRecoveryFile (
+  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
+  IN  UINTN                 VolumeIndex,
+  IN  CHAR16                *FileName,
+  OUT PEI_FILE_HANDLE       *Handle
+  );
+
+
+/**
+  Returns the number of DXE capsules residing on the device.
+  This function, by whatever mechanism, searches for DXE capsules from the associated device and
+  returns the number and maximum size in bytes of the capsules discovered.Entry 1 is assumed to be
+  the highest load priority and entry N is assumed to be the lowest priority.
+
+  @param  PeiServices             General-purpose services that are available to
+                                  every PEIM.
+  @param  This                    Indicates the
+                                  EFI_PEI_DEVICE_RECOVERY_MODULE_PPI instance.
+  @param  NumberRecoveryCapsules  Pointer to a caller-allocated UINTN.On output,
+                                  *NumberRecoveryCapsules contains the number of
+                                  recovery capsule images available for retrieval
+                                  from this PEIM instance.
+
+  @retval EFI_SUCCESS             The function completed successfully.
+
+**/
+EFI_STATUS
+EFIAPI
+GetNumberRecoveryCapsules (
+  IN EFI_PEI_SERVICES                               **PeiServices,
+  IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI             *This,
+  OUT UINTN                                         *NumberRecoveryCapsules
+  );
+
+
+/**
+  Returns the size and type of the requested recovery capsule.
+  This function returns the size and type of the capsule specified by CapsuleInstance.
+
+  @param  PeiServices             General-purpose services that are available to
+                                  every PEIM.
+  @param  This                    Indicates the
+                                  EFI_PEI_DEVICE_RECOVERY_MODULE_PPI instance.
+  @param  CapsuleInstance         Specifies for which capsule instance to
+                                  retrieve the information.T his parameter must
+                                  be between one and the value returned by
+                                  GetNumberRecoveryCapsules() in
+                                  NumberRecoveryCapsules.
+  @param  Size                    A pointer to a caller-allocated UINTN in which
+                                  the size of the requested recovery module is
+                                  returned.
+  @param  CapsuleType             A pointer to a caller-allocated EFI_GUID in
+                                  which the type of the requested recovery
+                                  capsule is returned.T he semantic meaning of
+                                  the value returned is defined by the
+                                  implementation.
+
+  @retval EFI_SUCCESS             The capsule type and size were retrieved.
+  @retval EFI_INVALID_PARAMETER   The input CapsuleInstance does not match any
+                                  discovered recovery capsule.
+
+**/
+EFI_STATUS
+EFIAPI
+GetRecoveryCapsuleInfo (
+  IN  EFI_PEI_SERVICES                              **PeiServices,
+  IN  EFI_PEI_DEVICE_RECOVERY_MODULE_PPI            *This,
+  IN  UINTN                                         CapsuleInstance,
+  OUT UINTN                                         *Size,
+  OUT EFI_GUID                                      *CapsuleType
+  );
+
+
+/**
+  Loads a DXE capsule from some media into memory.
+
+  This function, by whatever mechanism, retrieves a DXE capsule from some device
+  and loads it into memory. Note that the published interface is device neutral.
+
+  @param[in]     PeiServices       General-purpose services that are available
+                                   to every PEIM
+  @param[in]     This              Indicates the EFI_PEI_DEVICE_RECOVERY_MODULE_PPI
+                                   instance.
+  @param[in]     CapsuleInstance   Specifies which capsule instance to retrieve.
+  @param[out]    Buffer            Specifies a caller-allocated buffer in which
+                                   the requested recovery capsule will be returned.
+
+  @retval EFI_SUCCESS        The capsule was loaded correctly.
+  @retval EFI_DEVICE_ERROR   A device error occurred.
+  @retval EFI_NOT_FOUND      A requested recovery DXE capsule cannot be found.
+
+**/
+EFI_STATUS
+EFIAPI
+LoadRecoveryCapsule (
+  IN EFI_PEI_SERVICES                             **PeiServices,
+  IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI           *This,
+  IN UINTN                                        CapsuleInstance,
+  OUT VOID                                        *Buffer
+  );
+
+
+/**
+  This version is different from the version in Unicode collation
+  protocol in that this version strips off trailing blanks.
+  Converts an 8.3 FAT file name using an OEM character set
+  to a Null-terminated Unicode string.
+  Here does not expand DBCS FAT chars.
+
+  @param  FatSize           The size of the string Fat in bytes.
+  @param  Fat               A pointer to a Null-terminated string that contains
+                            an 8.3 file name using an OEM character set.
+  @param  Str               A pointer to a Null-terminated Unicode string. The
+                            string must be allocated in advance to hold FatSize
+                            Unicode characters
+
+**/
+VOID
+EngFatToStr (
+  IN UINTN                            FatSize,
+  IN CHAR8                            *Fat,
+  OUT CHAR16                          *Str
+  );
+
+
+/**
+  Performs a case-insensitive comparison of two Null-terminated Unicode strings.
+
+  @param  PrivateData       Global memory map for accessing global variables
+  @param  Str1              First string to perform case insensitive comparison.
+  @param  Str2              Second string to perform case insensitive comparison.
+
+**/
+BOOLEAN
+EngStriColl (
+  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
+  IN CHAR16                 *Str1,
+  IN CHAR16                 *Str2
+  );
+
+
+/**
+  Reads a block of data from the block device by calling
+  underlying Block I/O service.
+
+  @param  PrivateData       Global memory map for accessing global variables
+  @param  BlockDeviceNo     The index for the block device number.
+  @param  Lba               The logic block address to read data from.
+  @param  BufferSize        The size of data in byte to read.
+  @param  Buffer            The buffer of the
+
+  @retval EFI_DEVICE_ERROR  The specified block device number exceeds the maximum
+                            device number.
+  @retval EFI_DEVICE_ERROR  The maximum address has exceeded the maximum address
+                            of the block device.
+
+**/
+EFI_STATUS
+FatReadBlock (
+  IN  PEI_FAT_PRIVATE_DATA   *PrivateData,
+  IN  UINTN                  BlockDeviceNo,
+  IN  EFI_PEI_LBA            Lba,
+  IN  UINTN                  BufferSize,
+  OUT VOID                   *Buffer
+  );
+
+
+/**
+  Check if there is a valid FAT in the corresponding Block device
+  of the volume and if yes, fill in the relevant fields for the
+  volume structure. Note there should be a valid Block device number
+  already set.
+
+  @param  PrivateData            Global memory map for accessing global
+                                 variables.
+  @param  Volume                 On input, the BlockDeviceNumber field of the
+                                 Volume  should be a valid value. On successful
+                                 output, all  fields except the VolumeNumber
+                                 field is initialized.
+
+  @retval EFI_SUCCESS            A FAT is found and the volume structure is
+                                 initialized.
+  @retval EFI_NOT_FOUND          There is no FAT on the corresponding device.
+  @retval EFI_DEVICE_ERROR       There is something error while accessing device.
+
+**/
+EFI_STATUS
+FatGetBpbInfo (
+  IN      PEI_FAT_PRIVATE_DATA  *PrivateData,
+  IN OUT  PEI_FAT_VOLUME        *Volume
+  );
+
+
+/**
+  Gets the next cluster in the cluster chain.
+
+  @param  PrivateData            Global memory map for accessing global variables
+  @param  Volume                 The volume
+  @param  Cluster                The cluster
+  @param  NextCluster            The cluster number of the next cluster
+
+  @retval EFI_SUCCESS            The address is got
+  @retval EFI_INVALID_PARAMETER  ClusterNo exceeds the MaxCluster of the volume.
+  @retval EFI_DEVICE_ERROR       Read disk error
+
+**/
+EFI_STATUS
+FatGetNextCluster (
+  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
+  IN  PEI_FAT_VOLUME        *Volume,
+  IN  UINT32                Cluster,
+  OUT UINT32                *NextCluster
+  );
+
+
+/**
+  Disk reading.
+
+  @param  PrivateData       the global memory map;
+  @param  BlockDeviceNo     the block device to read;
+  @param  StartingAddress   the starting address.
+  @param  Size              the amount of data to read.
+  @param  Buffer            the buffer holding the data
+
+  @retval EFI_SUCCESS       The function completed successfully.
+  @retval EFI_DEVICE_ERROR  Something error.
+
+**/
+EFI_STATUS
+FatReadDisk (
+  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
+  IN  UINTN                 BlockDeviceNo,
+  IN  UINT64                StartingAddress,
+  IN  UINTN                 Size,
+  OUT VOID                  *Buffer
+  );
+
+
+/**
+  Set a file's CurrentPos and CurrentCluster, then compute StraightReadAmount.
+
+  @param  PrivateData            the global memory map
+  @param  File                   the file
+  @param  Pos                    the Position which is offset from the file's
+                                 CurrentPos
+
+  @retval EFI_SUCCESS            Success.
+  @retval EFI_INVALID_PARAMETER  Pos is beyond file's size.
+  @retval EFI_DEVICE_ERROR       Something error while accessing media.
+
+**/
+EFI_STATUS
+FatSetFilePos (
+  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
+  IN  PEI_FAT_FILE          *File,
+  IN  UINT32                Pos
+  );
+
+
+/**
+  Reads file data. Updates the file's CurrentPos.
+
+  @param  PrivateData            Global memory map for accessing global variables
+  @param  File                   The file.
+  @param  Size                   The amount of data to read.
+  @param  Buffer                 The buffer storing the data.
+
+  @retval EFI_SUCCESS            The data is read.
+  @retval EFI_INVALID_PARAMETER  File is invalid.
+  @retval EFI_DEVICE_ERROR       Something error while accessing media.
+
+**/
+EFI_STATUS
+FatReadFile (
+  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
+  IN  PEI_FAT_FILE          *File,
+  IN  UINTN                 Size,
+  OUT VOID                  *Buffer
+  );
+
+
+/**
+  This function reads the next item in the parent directory and
+  initializes the output parameter SubFile (CurrentPos is initialized to 0).
+  The function updates the CurrentPos of the parent dir to after the item read.
+  If no more items were found, the function returns EFI_NOT_FOUND.
+
+  @param  PrivateData            Global memory map for accessing global variables
+  @param  ParentDir              The parent directory.
+  @param  SubFile                The File structure containing the sub file that
+                                 is caught.
+
+  @retval EFI_SUCCESS            The next sub file is obtained.
+  @retval EFI_INVALID_PARAMETER  The ParentDir is not a directory.
+  @retval EFI_NOT_FOUND          No more sub file exists.
+  @retval EFI_DEVICE_ERROR       Something error while accessing media.
+
+**/
+EFI_STATUS
+FatReadNextDirectoryEntry (
+  IN  PEI_FAT_PRIVATE_DATA  *PrivateData,
+  IN  PEI_FAT_FILE          *ParentDir,
+  OUT PEI_FAT_FILE          *SubFile
+  );
+
+
+/**
+  This function finds partitions (logical devices) in physical block devices.
+
+  @param  PrivateData       Global memory map for accessing global variables.
+
+**/
+VOID
+FatFindPartitions (
+  IN  PEI_FAT_PRIVATE_DATA  *PrivateData
+  );
+
+#endif // _FAT_PEIM_H_
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/FatPei.inf b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/FatPei.inf
new file mode 100644
index 00000000..02c5a23f
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/FatPei.inf
@@ -0,0 +1,75 @@
+## @file
+#    Lite Fat driver only used in Pei Phase.
+#
+#  Copyright (c) 2006 - 2019, Intel Corporation. All rights reserved.<BR>
+#
+#  SPDX-License-Identifier: BSD-2-Clause-Patent
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = FatPei
+  MODULE_UNI_FILE                = FatPei.uni
+  FILE_GUID                      = 5B60CCFD-1011-4BCF-B7D1-BB99CA96A603
+  MODULE_TYPE                    = PEIM
+  VERSION_STRING                 = 1.0
+
+  ENTRY_POINT                    = FatPeimEntry
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64 EBC
+#
+
+[Sources]
+  Mbr.c
+  Gpt.c
+  Eltorito.c
+  Part.c
+  FatLiteApi.c
+  FatLiteLib.c
+  FatLiteAccess.c
+  FatLiteApi.h
+  FatLitePeim.h
+  FatLiteFmt.h
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+  MdeModulePkg/MdeModulePkg.dec
+
+
+[LibraryClasses]
+  PcdLib
+  BaseMemoryLib
+  MemoryAllocationLib
+  PeimEntryPoint
+  BaseLib
+  DebugLib
+  PeiServicesTablePointerLib
+  PeiServicesLib
+
+
+[Guids]
+  gRecoveryOnFatUsbDiskGuid                   ## SOMETIMES_CONSUMES   ## UNDEFINED
+  gRecoveryOnFatIdeDiskGuid                   ## SOMETIMES_CONSUMES   ## UNDEFINED
+  gRecoveryOnFatFloppyDiskGuid                ## SOMETIMES_CONSUMES   ## UNDEFINED
+  gRecoveryOnFatNvmeDiskGuid                  ## SOMETIMES_CONSUMES   ## UNDEFINED
+  gEfiPartTypeUnusedGuid                      ## SOMETIMES_CONSUMES   ## UNDEFINED
+
+
+[Ppis]
+  gEfiPeiVirtualBlockIoPpiGuid                  ## SOMETIMES_CONSUMES PPI_NOTIFY
+  gEfiPeiVirtualBlockIo2PpiGuid                 ## SOMETIMES_CONSUMES PPI_NOTIFY
+  gEfiPeiDeviceRecoveryModulePpiGuid            ## SOMETIMES_PRODUCES
+
+[Pcd]
+  gEfiMdeModulePkgTokenSpaceGuid.PcdRecoveryFileName         ## CONSUMES
+
+[Depex]
+  gEfiPeiMemoryDiscoveredPpiGuid
+
+[UserExtensions.TianoCore."ExtraFiles"]
+  FatPeiExtra.uni
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/FatPei.uni b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/FatPei.uni
new file mode 100644
index 00000000..8d8fc3d9
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/FatPei.uni
@@ -0,0 +1,16 @@
+// /** @file

+// Lite Fat driver only used in Pei Phase.

+//

+// Lite Fat driver only used in Pei Phase.

+//

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

+//

+// SPDX-License-Identifier: BSD-2-Clause-Patent

+//

+// **/

+

+

+#string STR_MODULE_ABSTRACT             #language en-US "Lite Fat driver only used in Pei Phase."

+

+#string STR_MODULE_DESCRIPTION          #language en-US "Lite Fat driver only used in Pei Phase."

+

diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/FatPeiExtra.uni b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/FatPeiExtra.uni
new file mode 100644
index 00000000..b3a735e4
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/FatPeiExtra.uni
@@ -0,0 +1,14 @@
+// /** @file

+// FatPei Localized Strings and Content

+//

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

+//

+// SPDX-License-Identifier: BSD-2-Clause-Patent

+//

+// **/

+

+#string STR_PROPERTIES_MODULE_NAME

+#language en-US

+"FAT File System Lite PEI Module"

+

+

diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/Gpt.c b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/Gpt.c
new file mode 100644
index 00000000..64d925d4
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/Gpt.c
@@ -0,0 +1,545 @@
+/** @file
+  Routines supporting partition discovery and
+  logical device reading
+
+Copyright (c) 2019 Intel Corporation. All rights reserved.<BR>
+
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include <IndustryStandard/Mbr.h>
+#include <Uefi/UefiGpt.h>
+#include <Library/BaseLib.h>
+#include "FatLitePeim.h"
+
+//
+// Assumption: 'a' and 'blocksize' are all UINT32 or UINT64.
+// If 'a' and 'blocksize' are not the same type, should use DivU64xU32 to calculate.
+//
+#define EFI_SIZE_TO_BLOCKS(a, blocksize)  (((a) / (blocksize)) + (((a) % (blocksize)) ? 1 : 0))
+
+//
+// GPT Partition Entry Status
+//
+typedef struct {
+  BOOLEAN OutOfRange;
+  BOOLEAN Overlap;
+  BOOLEAN OsSpecific;
+} EFI_PARTITION_ENTRY_STATUS;
+
+/**
+  Check if the CRC field in the Partition table header is valid.
+
+  @param[in]  PartHeader  Partition table header structure
+
+  @retval TRUE      the CRC is valid
+  @retval FALSE     the CRC is invalid
+
+**/
+BOOLEAN
+PartitionCheckGptHeaderCRC (
+  IN  EFI_PARTITION_TABLE_HEADER  *PartHeader
+  )
+{
+  UINT32      GptHdrCrc;
+  UINT32      Crc;
+
+  GptHdrCrc = PartHeader->Header.CRC32;
+
+  //
+  // Set CRC field to zero when doing calculation
+  //
+  PartHeader->Header.CRC32 = 0;
+
+  Crc = CalculateCrc32 (PartHeader, PartHeader->Header.HeaderSize);
+
+  //
+  // Restore Header CRC
+  //
+  PartHeader->Header.CRC32 = GptHdrCrc;
+
+  return (GptHdrCrc == Crc);
+}
+
+
+/**
+  Check if the CRC field in the Partition table header is valid
+  for Partition entry array.
+
+  @param[in]  PartHeader  Partition table header structure
+  @param[in]  PartEntry   The partition entry array
+
+  @retval TRUE      the CRC is valid
+  @retval FALSE     the CRC is invalid
+
+**/
+BOOLEAN
+PartitionCheckGptEntryArrayCRC (
+  IN  EFI_PARTITION_TABLE_HEADER *PartHeader,
+  IN  EFI_PARTITION_ENTRY        *PartEntry
+  )
+{
+  UINT32      Crc;
+  UINTN       Size;
+
+  Size = (UINTN)MultU64x32(PartHeader->NumberOfPartitionEntries, PartHeader->SizeOfPartitionEntry);
+  Crc  = CalculateCrc32 (PartEntry, Size);
+
+  return (BOOLEAN) (PartHeader->PartitionEntryArrayCRC32 == Crc);
+}
+
+/**
+  The function is used for valid GPT table. Both for Primary and Backup GPT header.
+
+  @param[in]  PrivateData       The global memory map
+  @param[in]  ParentBlockDevNo  The parent block device
+  @param[in]  IsPrimaryHeader   Indicate to which header will be checked.
+  @param[in]  PartHdr           Stores the partition table that is read
+
+  @retval TRUE      The partition table is valid
+  @retval FALSE     The partition table is not valid
+
+**/
+BOOLEAN
+PartitionCheckGptHeader (
+  IN  PEI_FAT_PRIVATE_DATA        *PrivateData,
+  IN  UINTN                       ParentBlockDevNo,
+  IN  BOOLEAN                     IsPrimaryHeader,
+  IN  EFI_PARTITION_TABLE_HEADER  *PartHdr
+  )
+{
+  PEI_FAT_BLOCK_DEVICE            *ParentBlockDev;
+  EFI_PEI_LBA                     Lba;
+  EFI_PEI_LBA                     AlternateLba;
+  EFI_PEI_LBA                     EntryArrayLastLba;
+
+  UINT64                          PartitionEntryArraySize;
+  UINT64                          PartitionEntryBlockNumb;
+  UINT32                          EntryArraySizeRemainder;
+
+  ParentBlockDev = &(PrivateData->BlockDevice[ParentBlockDevNo]);
+
+  if (IsPrimaryHeader) {
+    Lba          = PRIMARY_PART_HEADER_LBA;
+    AlternateLba = ParentBlockDev->LastBlock;
+  } else {
+    Lba          = ParentBlockDev->LastBlock;
+    AlternateLba = PRIMARY_PART_HEADER_LBA;
+  }
+
+  if ( (PartHdr->Header.Signature != EFI_PTAB_HEADER_ID) ||
+       (PartHdr->Header.Revision != 0x00010000) ||
+       (PartHdr->Header.HeaderSize < 92) ||
+       (PartHdr->Header.HeaderSize > ParentBlockDev->BlockSize) ||
+       (!PartitionCheckGptHeaderCRC (PartHdr)) ||
+       (PartHdr->Header.Reserved != 0)
+     ) {
+    DEBUG ((DEBUG_ERROR, "Invalid efi partition table header\n"));
+    return FALSE;
+  }
+
+  //
+  // |    Block0    |    Block1    |Block2 ~ FirstUsableLBA - 1|FirstUsableLBA, ... ,LastUsableLBA|LastUsableLBA+1 ~ LastBlock-1|  LastBlock  |
+  // |Protective MBR|Primary Header|Entry Array(At Least 16384)|             Partition            | Entry Array(At Least 16384) |BackUp Header|
+  //
+  // 1. Protective MBR is fixed at Block 0.
+  // 2. Primary Header is fixed at Block 1.
+  // 3. Backup Header is fixed at LastBlock.
+  // 4. Must be remain 128*128 bytes for primary entry array.
+  // 5. Must be remain 128*128 bytes for backup entry array.
+  // 6. SizeOfPartitionEntry must be equals to 128 * 2^n.
+  //
+  if ( (PartHdr->MyLBA != Lba) ||
+       (PartHdr->AlternateLBA != AlternateLba) ||
+       (PartHdr->FirstUsableLBA < 2 + EFI_SIZE_TO_BLOCKS (EFI_GPT_PART_ENTRY_MIN_SIZE, ParentBlockDev->BlockSize)) ||
+       (PartHdr->LastUsableLBA  > ParentBlockDev->LastBlock - 1 - EFI_SIZE_TO_BLOCKS (EFI_GPT_PART_ENTRY_MIN_SIZE, ParentBlockDev->BlockSize)) ||
+       (PartHdr->FirstUsableLBA > PartHdr->LastUsableLBA) ||
+       (PartHdr->PartitionEntryLBA < 2) ||
+       (PartHdr->PartitionEntryLBA > ParentBlockDev->LastBlock - 1) ||
+       (PartHdr->PartitionEntryLBA >= PartHdr->FirstUsableLBA && PartHdr->PartitionEntryLBA <= PartHdr->LastUsableLBA) ||
+       (PartHdr->SizeOfPartitionEntry%128 != 0) ||
+       (PartHdr->SizeOfPartitionEntry != sizeof (EFI_PARTITION_ENTRY))
+     ) {
+    DEBUG ((DEBUG_ERROR, "Invalid efi partition table header\n"));
+    return FALSE;
+  }
+
+  //
+  // Ensure the NumberOfPartitionEntries * SizeOfPartitionEntry doesn't overflow.
+  //
+  if (PartHdr->NumberOfPartitionEntries > DivU64x32 (MAX_UINTN, PartHdr->SizeOfPartitionEntry)) {
+    DEBUG ((DEBUG_ERROR, "Memory overflow in GPT Entry Array\n"));
+    return FALSE;
+  }
+
+  PartitionEntryArraySize = MultU64x32 (PartHdr->NumberOfPartitionEntries, PartHdr->SizeOfPartitionEntry);
+  EntryArraySizeRemainder = 0;
+  PartitionEntryBlockNumb = DivU64x32Remainder (PartitionEntryArraySize, ParentBlockDev->BlockSize, &EntryArraySizeRemainder);
+  if (EntryArraySizeRemainder != 0) {
+    PartitionEntryBlockNumb++;
+  }
+
+  if (IsPrimaryHeader) {
+    EntryArrayLastLba = PartHdr->FirstUsableLBA;
+  } else {
+    EntryArrayLastLba = ParentBlockDev->LastBlock;
+  }
+
+  //
+  // Make sure partition entry array not overlaps with partition area or the LastBlock.
+  //
+  if (PartHdr->PartitionEntryLBA + PartitionEntryBlockNumb > EntryArrayLastLba) {
+    DEBUG ((DEBUG_ERROR, "GPT Partition Entry Array Error!\n"));
+    DEBUG ((DEBUG_ERROR, "PartitionEntryArraySize = %lu.\n", PartitionEntryArraySize));
+    DEBUG ((DEBUG_ERROR, "PartitionEntryLBA = %lu.\n", PartHdr->PartitionEntryLBA));
+    DEBUG ((DEBUG_ERROR, "PartitionEntryBlockNumb = %lu.\n", PartitionEntryBlockNumb));
+    DEBUG ((DEBUG_ERROR, "EntryArrayLastLba = %lu.\n", EntryArrayLastLba));
+    return FALSE;
+  }
+
+  return TRUE;
+}
+
+/**
+  This function is used to verify each partition in block device.
+
+  @param[in]  PrivateData       The global memory map
+  @param[in]  ParentBlockDevNo  The parent block device
+  @param[in]  PartHdr           Stores the partition table that is read
+
+  @retval TRUE      The partition is valid
+  @retval FALSE     The partition is not valid
+
+**/
+BOOLEAN
+PartitionCheckGptEntryArray (
+  IN  PEI_FAT_PRIVATE_DATA        *PrivateData,
+  IN  UINTN                       ParentBlockDevNo,
+  IN  EFI_PARTITION_TABLE_HEADER  *PartHdr
+  )
+{
+  EFI_STATUS                      Status;
+  PEI_FAT_BLOCK_DEVICE            *ParentBlockDev;
+  PEI_FAT_BLOCK_DEVICE            *BlockDevPtr;
+
+  UINT64                          PartitionEntryArraySize;
+  UINT64                          PartitionEntryBlockNumb;
+  UINT32                          EntryArraySizeRemainder;
+
+  EFI_PARTITION_ENTRY             *PartitionEntryBuffer;
+  EFI_PARTITION_ENTRY_STATUS      *PartitionEntryStatus;
+
+  BOOLEAN                         Found;
+  EFI_LBA                         StartingLBA;
+  EFI_LBA                         EndingLBA;
+  UINTN                           Index;
+  UINTN                           Index1;
+  UINTN                           Index2;
+  EFI_PARTITION_ENTRY             *Entry;
+
+  PartitionEntryBuffer = NULL;
+  PartitionEntryStatus = NULL;
+
+  ParentBlockDev  = &(PrivateData->BlockDevice[ParentBlockDevNo]);
+  Found           = FALSE;
+
+  PartitionEntryArraySize = MultU64x32 (PartHdr->NumberOfPartitionEntries, PartHdr->SizeOfPartitionEntry);
+  EntryArraySizeRemainder = 0;
+  PartitionEntryBlockNumb = DivU64x32Remainder (PartitionEntryArraySize, ParentBlockDev->BlockSize, &EntryArraySizeRemainder);
+  if (EntryArraySizeRemainder != 0) {
+    PartitionEntryBlockNumb++;
+  }
+  PartitionEntryArraySize = MultU64x32 (PartitionEntryBlockNumb, ParentBlockDev->BlockSize);
+
+  PartitionEntryBuffer = (EFI_PARTITION_ENTRY *) AllocatePages (EFI_SIZE_TO_PAGES ((UINTN)PartitionEntryArraySize));
+  if (PartitionEntryBuffer == NULL) {
+    DEBUG ((DEBUG_ERROR, "Allocate memory error!\n"));
+    goto EXIT;
+  }
+
+  PartitionEntryStatus = (EFI_PARTITION_ENTRY_STATUS *) AllocatePages (EFI_SIZE_TO_PAGES (PartHdr->NumberOfPartitionEntries * sizeof (EFI_PARTITION_ENTRY_STATUS)));
+  if (PartitionEntryStatus == NULL) {
+    DEBUG ((DEBUG_ERROR, "Allocate memory error!\n"));
+    goto EXIT;
+  }
+  ZeroMem (PartitionEntryStatus, PartHdr->NumberOfPartitionEntries * sizeof (EFI_PARTITION_ENTRY_STATUS));
+
+  Status = FatReadBlock (
+             PrivateData,
+             ParentBlockDevNo,
+             PartHdr->PartitionEntryLBA,
+             (UINTN)PartitionEntryArraySize,
+             PartitionEntryBuffer
+             );
+  if (EFI_ERROR (Status)) {
+    DEBUG ((DEBUG_ERROR, "Read partition entry array error!\n"));
+    goto EXIT;
+  }
+
+  if (!PartitionCheckGptEntryArrayCRC (PartHdr, PartitionEntryBuffer)) {
+    DEBUG ((DEBUG_ERROR, "Partition entries CRC check fail\n"));
+    goto EXIT;
+  }
+
+  for (Index1 = 0; Index1 < PartHdr->NumberOfPartitionEntries; Index1++) {
+    Entry = (EFI_PARTITION_ENTRY *) ((UINT8 *) PartitionEntryBuffer + Index1 * PartHdr->SizeOfPartitionEntry);
+    if (CompareGuid (&Entry->PartitionTypeGUID, &gEfiPartTypeUnusedGuid)) {
+      continue;
+    }
+
+    StartingLBA = Entry->StartingLBA;
+    EndingLBA   = Entry->EndingLBA;
+    if (StartingLBA > EndingLBA ||
+        StartingLBA < PartHdr->FirstUsableLBA ||
+        StartingLBA > PartHdr->LastUsableLBA ||
+        EndingLBA < PartHdr->FirstUsableLBA ||
+        EndingLBA > PartHdr->LastUsableLBA
+        ) {
+      PartitionEntryStatus[Index1].OutOfRange = TRUE;
+      continue;
+    }
+
+    if ((Entry->Attributes & BIT1) != 0) {
+      //
+      // If Bit 1 is set, this indicate that this is an OS specific GUID partition.
+      //
+      PartitionEntryStatus[Index1].OsSpecific = TRUE;
+    }
+
+    for (Index2 = Index1 + 1; Index2 < PartHdr->NumberOfPartitionEntries; Index2++) {
+      Entry = (EFI_PARTITION_ENTRY *) ((UINT8 *) PartitionEntryBuffer + Index2 * PartHdr->SizeOfPartitionEntry);
+      if (CompareGuid (&Entry->PartitionTypeGUID, &gEfiPartTypeUnusedGuid)) {
+        continue;
+      }
+
+      if (Entry->EndingLBA >= StartingLBA && Entry->StartingLBA <= EndingLBA) {
+        //
+        // This region overlaps with the Index1'th region
+        //
+        PartitionEntryStatus[Index1].Overlap  = TRUE;
+        PartitionEntryStatus[Index2].Overlap  = TRUE;
+        continue;
+      }
+    }
+  }
+
+  for (Index = 0; Index < PartHdr->NumberOfPartitionEntries; Index++) {
+    if (CompareGuid (&PartitionEntryBuffer[Index].PartitionTypeGUID, &gEfiPartTypeUnusedGuid)||
+        PartitionEntryStatus[Index].OutOfRange ||
+        PartitionEntryStatus[Index].Overlap ||
+        PartitionEntryStatus[Index].OsSpecific) {
+      //
+      // Don't use null EFI Partition Entries, Invalid Partition Entries or OS specific
+      // partition Entries
+      //
+      continue;
+    }
+
+    if (PrivateData->BlockDeviceCount >= PEI_FAT_MAX_BLOCK_DEVICE) {
+      break;
+    }
+
+    Found                         = TRUE;
+    BlockDevPtr                   = &(PrivateData->BlockDevice[PrivateData->BlockDeviceCount]);
+
+    BlockDevPtr->BlockSize        = ParentBlockDev->BlockSize;
+    BlockDevPtr->LastBlock        = PartitionEntryBuffer[Index].EndingLBA;
+    BlockDevPtr->IoAlign          = ParentBlockDev->IoAlign;
+    BlockDevPtr->Logical          = TRUE;
+    BlockDevPtr->PartitionChecked = FALSE;
+    BlockDevPtr->StartingPos      = MultU64x32 (
+                                      PartitionEntryBuffer[Index].StartingLBA,
+                                      ParentBlockDev->BlockSize
+                                      );
+    BlockDevPtr->ParentDevNo      = ParentBlockDevNo;
+
+    PrivateData->BlockDeviceCount++;
+
+    DEBUG ((DEBUG_INFO, "Find GPT Partition [0x%lx",  PartitionEntryBuffer[Index].StartingLBA, BlockDevPtr->LastBlock));
+    DEBUG ((DEBUG_INFO, ", 0x%lx]\n", BlockDevPtr->LastBlock));
+    DEBUG ((DEBUG_INFO, "         BlockSize %x\n",  BlockDevPtr->BlockSize));
+  }
+
+EXIT:
+  if (PartitionEntryBuffer != NULL) {
+    FreePages (PartitionEntryBuffer, EFI_SIZE_TO_PAGES ((UINTN)PartitionEntryArraySize));
+  }
+
+  if (PartitionEntryStatus != NULL) {
+    FreePages (PartitionEntryStatus, EFI_SIZE_TO_PAGES (PartHdr->NumberOfPartitionEntries * sizeof (EFI_PARTITION_ENTRY_STATUS)));
+  }
+
+  return Found;
+}
+
+/**
+  The function is used to check GPT structure, include GPT header and GPT entry array.
+
+  1. Check GPT header.
+  2. Check partition entry array.
+  3. Check each partitions.
+
+  @param[in]  PrivateData       The global memory map
+  @param[in]  ParentBlockDevNo  The parent block device
+  @param[in]  IsPrimary         Indicate primary or backup to be check
+
+  @retval TRUE              Primary or backup GPT structure is valid.
+  @retval FALSE             Both primary and backup are invalid.
+
+**/
+BOOLEAN
+PartitionCheckGptStructure (
+  IN  PEI_FAT_PRIVATE_DATA      *PrivateData,
+  IN  UINTN                     ParentBlockDevNo,
+  IN  BOOLEAN                   IsPrimary
+  )
+{
+  EFI_STATUS                    Status;
+  PEI_FAT_BLOCK_DEVICE          *ParentBlockDev;
+  EFI_PARTITION_TABLE_HEADER    *PartHdr;
+  EFI_PEI_LBA                   GptHeaderLBA;
+
+  ParentBlockDev  = &(PrivateData->BlockDevice[ParentBlockDevNo]);
+  PartHdr         = (EFI_PARTITION_TABLE_HEADER *) PrivateData->BlockData;
+
+  if (IsPrimary) {
+    GptHeaderLBA = PRIMARY_PART_HEADER_LBA;
+  } else {
+    GptHeaderLBA = ParentBlockDev->LastBlock;
+  }
+
+  Status = FatReadBlock (
+             PrivateData,
+             ParentBlockDevNo,
+             GptHeaderLBA,
+             ParentBlockDev->BlockSize,
+             PartHdr
+             );
+  if (EFI_ERROR (Status)) {
+    return FALSE;
+  }
+
+  if (!PartitionCheckGptHeader (PrivateData, ParentBlockDevNo, IsPrimary, PartHdr)) {
+    return FALSE;
+  }
+
+  if (!PartitionCheckGptEntryArray (PrivateData, ParentBlockDevNo, PartHdr)) {
+    return FALSE;
+  }
+
+  return TRUE;
+}
+
+/**
+  This function is used to check protective MBR structure before checking GPT.
+
+  @param[in]  PrivateData       The global memory map
+  @param[in]  ParentBlockDevNo  The parent block device
+
+  @retval TRUE              Valid protective MBR
+  @retval FALSE             Invalid MBR
+**/
+BOOLEAN
+PartitionCheckProtectiveMbr (
+  IN  PEI_FAT_PRIVATE_DATA    *PrivateData,
+  IN  UINTN                   ParentBlockDevNo
+  )
+{
+  EFI_STATUS                  Status;
+  MASTER_BOOT_RECORD          *ProtectiveMbr;
+  MBR_PARTITION_RECORD        *MbrPartition;
+  PEI_FAT_BLOCK_DEVICE        *ParentBlockDev;
+  UINTN                       Index;
+
+  ProtectiveMbr   = (MASTER_BOOT_RECORD *) PrivateData->BlockData;
+  ParentBlockDev  = &(PrivateData->BlockDevice[ParentBlockDevNo]);
+
+  //
+  // Read Protective MBR
+  //
+  Status = FatReadBlock (
+             PrivateData,
+             ParentBlockDevNo,
+             0,
+             ParentBlockDev->BlockSize,
+             ProtectiveMbr
+             );
+  if (EFI_ERROR (Status)) {
+    DEBUG ((DEBUG_ERROR, "GPT Error When Read Protective Mbr From Partition!\n"));
+    return FALSE;
+  }
+
+  if (ProtectiveMbr->Signature != MBR_SIGNATURE) {
+    DEBUG ((DEBUG_ERROR, "Protective Mbr Signature is invalid!\n"));
+    return FALSE;
+  }
+
+  //
+  // The partition define in UEFI Spec Table 17.
+  // Boot Code, Unique MBR Disk Signature, Unknown.
+  // These parts will not be used by UEFI, so we skip to check them.
+  //
+  for (Index = 0; Index < MAX_MBR_PARTITIONS; Index++) {
+    MbrPartition = (MBR_PARTITION_RECORD *)&ProtectiveMbr->Partition[Index];
+    if (MbrPartition->BootIndicator   == 0x00 &&
+        MbrPartition->StartSector     == 0x02 &&
+        MbrPartition->OSIndicator     == PMBR_GPT_PARTITION &&
+        UNPACK_UINT32 (MbrPartition->StartingLBA) == 1
+       ) {
+      return TRUE;
+    }
+  }
+
+  DEBUG ((DEBUG_ERROR, "Protective Mbr, All Partition Entry Are Empty!\n"));
+  return FALSE;
+}
+
+/**
+  This function is used for finding GPT partition on block device.
+  As follow UEFI spec we should check protective MBR first and then
+  try to check both primary/backup GPT structures.
+
+  @param[in]  PrivateData       The global memory map
+  @param[in]  ParentBlockDevNo  The parent block device
+
+  @retval TRUE              New partitions are detected and logical block devices
+                            are added to block device array
+  @retval FALSE             No new partitions are added
+
+**/
+BOOLEAN
+FatFindGptPartitions (
+  IN  PEI_FAT_PRIVATE_DATA *PrivateData,
+  IN  UINTN                ParentBlockDevNo
+  )
+{
+  BOOLEAN                      Found;
+  PEI_FAT_BLOCK_DEVICE         *ParentBlockDev;
+
+  if (ParentBlockDevNo > PEI_FAT_MAX_BLOCK_DEVICE - 1) {
+    return FALSE;
+  }
+
+  ParentBlockDev  = &(PrivateData->BlockDevice[ParentBlockDevNo]);
+  if (ParentBlockDev->BlockSize > PEI_FAT_MAX_BLOCK_SIZE) {
+    DEBUG ((DEBUG_ERROR, "Device BlockSize %x exceed FAT_MAX_BLOCK_SIZE\n", ParentBlockDev->BlockSize));
+    return FALSE;
+  }
+
+  if (!PartitionCheckProtectiveMbr (PrivateData, ParentBlockDevNo)) {
+    return FALSE;
+  }
+
+  Found = PartitionCheckGptStructure (PrivateData, ParentBlockDevNo, TRUE);
+  if (!Found) {
+    DEBUG ((DEBUG_ERROR, "Primary GPT Header Error, Try to Check Backup GPT Header!\n"));
+    Found = PartitionCheckGptStructure (PrivateData, ParentBlockDevNo, FALSE);
+  }
+
+  if (Found) {
+    ParentBlockDev->PartitionChecked = TRUE;
+  }
+
+  return Found;
+}
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/Mbr.c b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/Mbr.c
new file mode 100644
index 00000000..5de24c83
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/Mbr.c
@@ -0,0 +1,175 @@
+/** @file
+  Routines supporting partition discovery and
+  logical device reading
+
+Copyright (c) 2006 - 2019, Intel Corporation. All rights reserved.<BR>
+
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include <IndustryStandard/Mbr.h>
+#include "FatLitePeim.h"
+
+/**
+  Test to see if the Mbr buffer is a valid MBR
+
+  @param[in]  Mbr               Parent Handle
+  @param[in]  LastLba           Last Lba address on the device.
+
+  @retval     TRUE              Mbr is a Valid MBR
+  @retval     FALSE             Mbr is not a Valid MBR
+
+**/
+BOOLEAN
+PartitionValidMbr (
+  IN  MASTER_BOOT_RECORD      *Mbr,
+  IN  EFI_PEI_LBA             LastLba
+  )
+{
+  UINT32  StartingLBA;
+  UINT32  EndingLBA;
+  UINT32  NewEndingLBA;
+  INTN    Index1;
+  INTN    Index2;
+  BOOLEAN MbrValid;
+
+  if (Mbr->Signature != MBR_SIGNATURE) {
+    return FALSE;
+  }
+  //
+  // The BPB also has this signature, so it can not be used alone.
+  //
+  MbrValid = FALSE;
+  for (Index1 = 0; Index1 < MAX_MBR_PARTITIONS; Index1++) {
+    if (Mbr->Partition[Index1].OSIndicator == 0x00 || UNPACK_UINT32 (Mbr->Partition[Index1].SizeInLBA) == 0) {
+      continue;
+    }
+
+    MbrValid    = TRUE;
+    StartingLBA = UNPACK_UINT32 (Mbr->Partition[Index1].StartingLBA);
+    EndingLBA   = StartingLBA + UNPACK_UINT32 (Mbr->Partition[Index1].SizeInLBA) - 1;
+    if (EndingLBA > LastLba) {
+      //
+      // Compatibility Errata:
+      //  Some systems try to hide drive space with their INT 13h driver
+      //  This does not hide space from the OS driver. This means the MBR
+      //  that gets created from DOS is smaller than the MBR created from
+      //  a real OS (NT & Win98). This leads to BlockIo->LastBlock being
+      //  wrong on some systems FDISKed by the OS.
+      //
+      //  return FALSE Because no block devices on a system are implemented
+      //  with INT 13h
+      //
+      return FALSE;
+    }
+
+    for (Index2 = Index1 + 1; Index2 < MAX_MBR_PARTITIONS; Index2++) {
+      if (Mbr->Partition[Index2].OSIndicator == 0x00 || UNPACK_INT32 (Mbr->Partition[Index2].SizeInLBA) == 0) {
+        continue;
+      }
+
+      NewEndingLBA = UNPACK_UINT32 (Mbr->Partition[Index2].StartingLBA) + UNPACK_UINT32 (Mbr->Partition[Index2].SizeInLBA) - 1;
+      if (NewEndingLBA >= StartingLBA && UNPACK_UINT32 (Mbr->Partition[Index2].StartingLBA) <= EndingLBA) {
+        //
+        // This region overlaps with the Index1'th region
+        //
+        return FALSE;
+      }
+    }
+  }
+  //
+  // Non of the regions overlapped so MBR is O.K.
+  //
+  return MbrValid;
+}
+
+/**
+  This function finds Mbr partitions. Main algorithm
+  is ported from DXE partition driver.
+
+  @param[in]  PrivateData       The global memory map
+  @param[in]  ParentBlockDevNo  The parent block device
+
+  @retval TRUE              New partitions are detected and logical block devices
+                            are added to block device array
+  @retval FALSE             No new partitions are added
+
+**/
+BOOLEAN
+FatFindMbrPartitions (
+  IN  PEI_FAT_PRIVATE_DATA *PrivateData,
+  IN  UINTN                ParentBlockDevNo
+  )
+{
+  EFI_STATUS            Status;
+  MASTER_BOOT_RECORD    *Mbr;
+  UINTN                 Index;
+  BOOLEAN               Found;
+  PEI_FAT_BLOCK_DEVICE  *ParentBlockDev;
+  PEI_FAT_BLOCK_DEVICE  *BlockDev;
+
+  if (ParentBlockDevNo > PEI_FAT_MAX_BLOCK_DEVICE - 1) {
+    return FALSE;
+  }
+
+  ParentBlockDev  = &(PrivateData->BlockDevice[ParentBlockDevNo]);
+
+  if (ParentBlockDev->BlockSize > PEI_FAT_MAX_BLOCK_SIZE) {
+    DEBUG((DEBUG_ERROR, "Device BlockSize %x exceeds FAT_MAX_BLOCK_SIZE\n", ParentBlockDev->BlockSize));
+    return FALSE;
+  }
+
+  Found           = FALSE;
+  Mbr             = (MASTER_BOOT_RECORD *) PrivateData->BlockData;
+
+  Status = FatReadBlock (
+            PrivateData,
+            ParentBlockDevNo,
+            0,
+            ParentBlockDev->BlockSize,
+            Mbr
+            );
+
+  if (EFI_ERROR (Status) || !PartitionValidMbr (Mbr, ParentBlockDev->LastBlock)) {
+    goto Done;
+  }
+  //
+  // We have a valid mbr - add each partition
+  //
+  for (Index = 0; Index < MAX_MBR_PARTITIONS; Index++) {
+    if (Mbr->Partition[Index].OSIndicator == 0x00 || UNPACK_INT32 (Mbr->Partition[Index].SizeInLBA) == 0) {
+      //
+      // Don't use null MBR entries
+      //
+      continue;
+    }
+    //
+    // Register this partition
+    //
+    if (PrivateData->BlockDeviceCount < PEI_FAT_MAX_BLOCK_DEVICE) {
+
+      Found                       = TRUE;
+
+      BlockDev                    = &(PrivateData->BlockDevice[PrivateData->BlockDeviceCount]);
+
+      BlockDev->BlockSize         = MBR_SIZE;
+      BlockDev->LastBlock         = UNPACK_INT32 (Mbr->Partition[Index].SizeInLBA) - 1;
+      BlockDev->IoAlign           = ParentBlockDev->IoAlign;
+      BlockDev->Logical           = TRUE;
+      BlockDev->PartitionChecked  = FALSE;
+      BlockDev->StartingPos = MultU64x32 (
+                                UNPACK_INT32 (Mbr->Partition[Index].StartingLBA),
+                                ParentBlockDev->BlockSize
+                                );
+      BlockDev->ParentDevNo = ParentBlockDevNo;
+
+      PrivateData->BlockDeviceCount++;
+    }
+  }
+
+Done:
+
+  ParentBlockDev->PartitionChecked = TRUE;
+  return Found;
+}
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/Part.c b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/Part.c
new file mode 100644
index 00000000..d0334660
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/Part.c
@@ -0,0 +1,104 @@
+/** @file
+  Routines supporting partition discovery and
+  logical device reading
+
+Copyright (c) 2006 - 2019, Intel Corporation. All rights reserved.<BR>
+
+SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "FatLitePeim.h"
+
+/**
+  This function finds Eltorito partitions. Main algorithm
+  is ported from DXE partition driver.
+
+  @param[in]  PrivateData       The global memory map
+  @param[in]  ParentBlockDevNo  The parent block device
+
+  @retval TRUE              New partitions are detected and logical block devices
+                            are added to block device array
+  @retval FALSE             No new partitions are added
+
+**/
+BOOLEAN
+FatFindEltoritoPartitions (
+  IN  PEI_FAT_PRIVATE_DATA *PrivateData,
+  IN  UINTN                ParentBlockDevNo
+  );
+
+/**
+  This function finds Mbr partitions. Main algorithm
+  is ported from DXE partition driver.
+
+  @param[in]  PrivateData       The global memory map
+  @param[in]  ParentBlockDevNo  The parent block device
+
+  @retval TRUE              New partitions are detected and logical block devices
+                            are added to block device array
+  @retval FALSE             No new partitions are added
+
+**/
+BOOLEAN
+FatFindMbrPartitions (
+  IN  PEI_FAT_PRIVATE_DATA *PrivateData,
+  IN  UINTN                ParentBlockDevNo
+  );
+
+/**
+  This function is used for finding GPT partition on block device.
+  As follow UEFI spec we should check protective MBR first and then
+  try to check both primary/backup GPT structures.
+
+  @param[in]  PrivateData       The global memory map
+  @param[in]  ParentBlockDevNo  The parent block device
+
+  @retval TRUE              New partitions are detected and logical block devices
+                            are added to block device array
+  @retval FALSE             No new partitions are added
+
+**/
+BOOLEAN
+FatFindGptPartitions (
+  IN  PEI_FAT_PRIVATE_DATA *PrivateData,
+  IN  UINTN                ParentBlockDevNo
+  );
+
+/**
+  This function finds partitions (logical devices) in physical block devices.
+
+  @param  PrivateData       Global memory map for accessing global variables.
+
+**/
+VOID
+FatFindPartitions (
+  IN  PEI_FAT_PRIVATE_DATA  *PrivateData
+  )
+{
+  BOOLEAN Found;
+  UINTN   Index;
+
+  do {
+    Found = FALSE;
+
+    for (Index = 0; Index < PrivateData->BlockDeviceCount; Index++) {
+      if (!PrivateData->BlockDevice[Index].PartitionChecked) {
+        if (FatFindGptPartitions (PrivateData, Index)) {
+          Found = TRUE;
+          continue;
+        }
+
+        if (FatFindMbrPartitions (PrivateData, Index)) {
+          Found = TRUE;
+          continue;
+        }
+
+        if (FatFindEltoritoPartitions (PrivateData, Index)) {
+          Found = TRUE;
+          continue;
+        }
+      }
+    }
+  } while (Found && PrivateData->BlockDeviceCount <= PEI_FAT_MAX_BLOCK_DEVICE);
+}
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/FatPkg.ci.yaml b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPkg.ci.yaml
new file mode 100644
index 00000000..7dc1829b
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPkg.ci.yaml
@@ -0,0 +1,65 @@
+## @file
+# CI configuration for FatPkg
+#
+# Copyright (c) Microsoft Corporation
+# Copyright (c) 2020, Intel Corporation. All rights reserved.<BR>
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+{
+    "LicenseCheck": {
+        "IgnoreFiles": []
+    },
+    "EccCheck": {
+        ## Exception sample looks like below:
+        ## "ExceptionList": [
+        ##     "<ErrorID>", "<KeyWord>"
+        ## ]
+        "ExceptionList": [
+        ],
+        ## Both file path and directory path are accepted.
+        "IgnoreFiles": [
+        ]
+    },
+    "CompilerPlugin": {
+        "DscPath": "FatPkg.dsc"
+    },
+    "CharEncodingCheck": {
+        "IgnoreFiles": []
+    },
+    "DependencyCheck": {
+        "AcceptableDependencies": [
+            "MdePkg/MdePkg.dec",
+            "MdeModulePkg/MdeModulePkg.dec",
+        ],
+        # For host based unit tests
+        "AcceptableDependencies-HOST_APPLICATION":[],
+        # For UEFI shell based apps
+        "AcceptableDependencies-UEFI_APPLICATION":[],
+        "IgnoreInf": []
+    },
+    "DscCompleteCheck": {
+        "IgnoreInf": [],
+        "DscPath": "FatPkg.dsc"
+    },
+    "GuidCheck": {
+        "IgnoreGuidName": [],
+        "IgnoreGuidValue": [],
+        "IgnoreFoldersAndFiles": []
+    },
+    "LibraryClassCheck": {
+        "IgnoreHeaderFile": []
+    },
+    "SpellCheck": {
+        "ExtendWords": [
+            "ELTORITO",
+            "FHAND",
+            "IFILE",
+            "OFILE",
+            "FDISKed",
+            "Lfnbuffer",
+            "FFFFFFFFL",
+            "CDVOL",
+            "DMDEPKG"
+        ]
+    }
+}
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/FatPkg.dec b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPkg.dec
new file mode 100644
index 00000000..0d0cc194
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPkg.dec
@@ -0,0 +1,19 @@
+## @file
+#  FAT Package
+#
+#  FAT 32 Driver
+#  Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
+#
+#  SPDX-License-Identifier: BSD-2-Clause-Patent
+#
+##
+
+[Defines]
+  DEC_SPECIFICATION              = 0x00010005
+  PACKAGE_NAME                   = FatPkg
+  PACKAGE_UNI_FILE               = FatPkg.uni
+  PACKAGE_GUID                   = 8EA68A2C-99CB-4332-85C6-DD5864EAA674
+  PACKAGE_VERSION                = 0.3
+
+[UserExtensions.TianoCore."ExtraFiles"]
+  FatPkgExtra.uni
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/FatPkg.dsc b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPkg.dsc
new file mode 100644
index 00000000..5cdfdaab
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPkg.dsc
@@ -0,0 +1,84 @@
+## @file
+#  Build Binary Enhanced Fat Driver Modules.
+#
+#  This Platform file is used to generate the Binary Fat Drivers
+#  for EDK II Prime release.
+#  Copyright (c) 2007 - 2021, Intel Corporation. All rights reserved.<BR>
+#  Copyright (c) 2020, Hewlett Packard Enterprise Development LP. All rights reserved.<BR>
+#
+#  SPDX-License-Identifier: BSD-2-Clause-Patent
+#
+##
+
+[Defines]
+  PLATFORM_NAME                  = Fat
+  PLATFORM_GUID                  = 25b55dbc-9d0b-4a32-80da-46e1273d622c
+  PLATFORM_VERSION               = 0.3
+  DSC_SPECIFICATION              = 0x00010005
+  SUPPORTED_ARCHITECTURES        = IA32|X64|EBC|ARM|AARCH64|RISCV64
+  OUTPUT_DIRECTORY               = Build/Fat
+  BUILD_TARGETS                  = DEBUG|RELEASE|NOOPT
+  SKUID_IDENTIFIER               = DEFAULT
+
+[BuildOptions]
+  GCC:RELEASE_*_*_CC_FLAGS             = -DMDEPKG_NDEBUG
+  INTEL:RELEASE_*_*_CC_FLAGS           = /D MDEPKG_NDEBUG
+  MSFT:RELEASE_*_*_CC_FLAGS            = /D MDEPKG_NDEBUG
+  RVCT:RELEASE_*_*_CC_FLAGS            = -DMDEPKG_NDEBUG
+  *_*_*_CC_FLAGS                       = -D DISABLE_NEW_DEPRECATED_INTERFACES
+
+!include MdePkg/MdeLibs.dsc.inc
+
+[LibraryClasses]
+  #
+  # Entry Point Libraries
+  #
+  UefiDriverEntryPoint|MdePkg/Library/UefiDriverEntryPoint/UefiDriverEntryPoint.inf
+  #
+  # Common Libraries
+  #
+  BaseLib|MdePkg/Library/BaseLib/BaseLib.inf
+  BaseMemoryLib|MdePkg/Library/BaseMemoryLib/BaseMemoryLib.inf
+  UefiLib|MdePkg/Library/UefiLib/UefiLib.inf
+  PrintLib|MdePkg/Library/BasePrintLib/BasePrintLib.inf
+  PcdLib|MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf
+  MemoryAllocationLib|MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf
+  UefiBootServicesTableLib|MdePkg/Library/UefiBootServicesTableLib/UefiBootServicesTableLib.inf
+  UefiRuntimeServicesTableLib|MdePkg/Library/UefiRuntimeServicesTableLib/UefiRuntimeServicesTableLib.inf
+  DebugLib|MdePkg/Library/BaseDebugLibNull/BaseDebugLibNull.inf
+  DebugPrintErrorLevelLib|MdePkg/Library/BaseDebugPrintErrorLevelLib/BaseDebugPrintErrorLevelLib.inf
+  DevicePathLib|MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.inf
+
+[LibraryClasses.common.PEIM]
+  PeimEntryPoint|MdePkg/Library/PeimEntryPoint/PeimEntryPoint.inf
+  PeiServicesLib|MdePkg/Library/PeiServicesLib/PeiServicesLib.inf
+  PeiServicesTablePointerLib|MdePkg/Library/PeiServicesTablePointerLib/PeiServicesTablePointerLib.inf
+  HobLib|MdePkg/Library/PeiHobLib/PeiHobLib.inf
+  MemoryAllocationLib|MdePkg/Library/PeiMemoryAllocationLib/PeiMemoryAllocationLib.inf
+
+[LibraryClasses.ARM, LibraryClasses.AARCH64]
+  NULL|ArmPkg/Library/CompilerIntrinsicsLib/CompilerIntrinsicsLib.inf
+  NULL|MdePkg/Library/BaseStackCheckLib/BaseStackCheckLib.inf
+
+###################################################################################################
+#
+# Components Section - list of the modules and components that will be processed by compilation
+#                      tools and the EDK II tools to generate PE32/PE32+/Coff image files.
+#
+# Note: The EDK II DSC file is not used to specify how compiled binary images get placed
+#       into firmware volume images. This section is just a list of modules to compile from
+#       source into UEFI-compliant binaries.
+#       It is the FDF file that contains information on combining binary files into firmware
+#       volume images, whose concept is beyond UEFI and is described in PI specification.
+#       Binary modules do not need to be listed in this section, as they should be
+#       specified in the FDF file. For example: Shell binary (Shell_Full.efi), FAT binary (Fat.efi),
+#       Logo (Logo.bmp), and etc.
+#       There may also be modules listed in this section that are not required in the FDF file,
+#       When a module listed here is excluded from FDF file, then UEFI-compliant binary will be
+#       generated for it, but the binary will not be put into any firmware volume.
+#
+###################################################################################################
+
+[Components]
+  FatPkg/FatPei/FatPei.inf
+  FatPkg/EnhancedFatDxe/Fat.inf
diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/FatPkg.uni b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPkg.uni
new file mode 100644
index 00000000..659b8b32
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPkg.uni
@@ -0,0 +1,20 @@
+// /** @file

+// Module implementations for FAT file system, FAT 32 UEFI Driver and FAT PEI Module

+//

+// FAT Package

+//

+// FAT 32 Driver

+//

+// Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>

+//

+// SPDX-License-Identifier: BSD-2-Clause-Patent

+//

+// **/

+

+

+#string STR_PACKAGE_ABSTRACT            #language en-US "Module implementations for FAT file system, FAT 32 UEFI Driver and FAT PEI Module"

+

+#string STR_PACKAGE_DESCRIPTION         #language en-US "This Package contains module implementation about FAT file system, FAT 32 UEFI Driver and FAT PEI Module."

+

+

+

diff --git a/src/VBox/Devices/EFI/Firmware/FatPkg/FatPkgExtra.uni b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPkgExtra.uni
new file mode 100644
index 00000000..d9c0c9e4
--- /dev/null
+++ b/src/VBox/Devices/EFI/Firmware/FatPkg/FatPkgExtra.uni
@@ -0,0 +1,14 @@
+// /** @file

+// Fat Package Localized Strings and Content.

+//

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

+//

+// SPDX-License-Identifier: BSD-2-Clause-Patent

+//

+// **/

+

+#string STR_PROPERTIES_PACKAGE_NAME

+#language en-US

+"Fat package"

+

+