ArmPkg/BdsLib: Upgrade the library to use natively the Device Path

The previous version was using the string representation of the Device Path.
This new version takes as paramater the binary representation of the Device Path

It also tries to detect which kind of device support it refers by using the remaining
part of the Device Path after it has been loaded by gBS->ConnectController()

Lots of bug have been fixed as well in this new version.



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

1 files changed, 786 insertions, 126 deletions

diff --git a/ArmPkg/Library/BdsLib/BdsFilePath.c b/ArmPkg/Library/BdsLib/BdsFilePath.c
index b1460b9c9d..f7a06e5a89 100644
--- a/ArmPkg/Library/BdsLib/BdsFilePath.c
+++ b/ArmPkg/Library/BdsLib/BdsFilePath.c
@@ -14,169 +14,829 @@
 
 #include "BdsInternal.h"
 
-// Count the number of DevicePath Node
-static UINTN NumberNodeFromDevicePath(
-    IN  EFI_DEVICE_PATH_PROTOCOL* DevicePath
-) {
-    UINTN NumberDevicePathNode = 0;
-
-    while (!IsDevicePathEnd (DevicePath)) {
-        NumberDevicePathNode++;
-        DevicePath = NextDevicePathNode(DevicePath);
+#include <Protocol/UsbIo.h>
+#include <Protocol/DiskIo.h>
+
+#define IS_DEVICE_PATH_NODE(node,type,subtype) (((node)->Type == (type)) && ((node)->SubType == (subtype)))
+
+// Extract the FilePath from the Device Path
+CHAR16*
+BdsExtractFilePathFromDevicePath (
+  IN  CONST CHAR16    *StrDevicePath,
+  IN  UINTN           NumberDevicePathNode
+  )
+{
+  UINTN       Node;
+  CHAR16      *Str;
+
+  Str = (CHAR16*)StrDevicePath;
+  Node = 0;
+  while ((Str != NULL) && (*Str != L'\0') && (Node < NumberDevicePathNode)) {
+    if ((*Str == L'/') || (*Str == L'\\')) {
+        Node++;
     }
-    return NumberDevicePathNode;
+    Str++;
+  }
+
+  if (*Str == L'\0') {
+    return NULL;
+  } else {
+    return Str;
+  }
 }
 
-// Extract the FilePath from the Device Path
-CHAR16* BdsExtractFilePathFromDevicePath(
-    IN  CONST CHAR16    *StrDevicePath,
-    IN  UINTN           NumberDevicePathNode
-) {
-    UINTN       Node;
-    CHAR16      *Str;
-
-    Str = (CHAR16*)StrDevicePath;
-    Node = 0;
-    while ((Str != NULL) && (*Str != L'\0') && (Node < NumberDevicePathNode)) {
-        if ((*Str == L'/') || (*Str == L'\\')) {
-            Node++;
+BOOLEAN
+BdsIsRemovableUsb (
+  IN  EFI_DEVICE_PATH*  DevicePath
+  )
+{
+  return ((DevicePathType (DevicePath) == MESSAGING_DEVICE_PATH) &&
+          ((DevicePathSubType (DevicePath) == MSG_USB_CLASS_DP) ||
+           (DevicePathSubType (DevicePath) == MSG_USB_WWID_DP)));
+}
+
+EFI_STATUS
+BdsGetDeviceUsb (
+  IN  EFI_DEVICE_PATH*  RemovableDevicePath,
+  OUT EFI_HANDLE*       DeviceHandle,
+  OUT EFI_DEVICE_PATH** NewDevicePath
+  )
+{
+  EFI_STATUS                    Status;
+  UINTN                         Index;
+  UINTN                         UsbIoHandleCount;
+  EFI_HANDLE                    *UsbIoBuffer;
+  EFI_DEVICE_PATH*              UsbIoDevicePath;
+  EFI_DEVICE_PATH*              TmpDevicePath;
+  USB_WWID_DEVICE_PATH*         WwidDevicePath1;
+  USB_WWID_DEVICE_PATH*         WwidDevicePath2;
+  USB_CLASS_DEVICE_PATH*        UsbClassDevicePath1;
+  USB_CLASS_DEVICE_PATH*        UsbClassDevicePath2;
+
+  // Get all the UsbIo handles
+  UsbIoHandleCount = 0;
+  Status = gBS->LocateHandleBuffer (ByProtocol, &gEfiUsbIoProtocolGuid, NULL, &UsbIoHandleCount, &UsbIoBuffer);
+  if (EFI_ERROR(Status) || (UsbIoHandleCount == 0)) {
+    return Status;
+  }
+
+  // Check if one of the handles matches the USB description
+  for (Index = 0; Index < UsbIoHandleCount; Index++) {
+    Status = gBS->HandleProtocol (UsbIoBuffer[Index], &gEfiDevicePathProtocolGuid, (VOID *) &UsbIoDevicePath);
+    if (!EFI_ERROR(Status)) {
+      TmpDevicePath = UsbIoDevicePath;
+      while (!IsDevicePathEnd (TmpDevicePath)) {
+        // Check if the Device Path node is a USB Removable device Path node
+        if (BdsIsRemovableUsb (TmpDevicePath)) {
+          if (TmpDevicePath->SubType == MSG_USB_WWID_DP) {
+            WwidDevicePath1 = (USB_WWID_DEVICE_PATH*)RemovableDevicePath;
+            WwidDevicePath2 = (USB_WWID_DEVICE_PATH*)TmpDevicePath;
+            if ((WwidDevicePath1->VendorId == WwidDevicePath2->VendorId) &&
+                (WwidDevicePath1->ProductId == WwidDevicePath2->ProductId) &&
+                (CompareMem (WwidDevicePath1+1, WwidDevicePath2+1, DevicePathNodeLength(WwidDevicePath1)-sizeof(USB_WWID_DEVICE_PATH)) == 0))
+            {
+              *DeviceHandle = UsbIoBuffer[Index];
+              // Add the additional original Device Path Nodes (eg: FilePath Device Path Node) to the new Device Path
+              *NewDevicePath = AppendDevicePath (UsbIoDevicePath, NextDevicePathNode(RemovableDevicePath));
+              return EFI_SUCCESS;
+            }
+          } else {
+            UsbClassDevicePath1 = (USB_CLASS_DEVICE_PATH*)RemovableDevicePath;
+            UsbClassDevicePath2 = (USB_CLASS_DEVICE_PATH*)TmpDevicePath;
+            if ((UsbClassDevicePath1->VendorId != 0xFFFF) && (UsbClassDevicePath1->VendorId == UsbClassDevicePath2->VendorId) &&
+                (UsbClassDevicePath1->ProductId != 0xFFFF) && (UsbClassDevicePath1->ProductId == UsbClassDevicePath2->ProductId) &&
+                (UsbClassDevicePath1->DeviceClass != 0xFF) && (UsbClassDevicePath1->DeviceClass == UsbClassDevicePath2->DeviceClass) &&
+                (UsbClassDevicePath1->DeviceSubClass != 0xFF) && (UsbClassDevicePath1->DeviceSubClass == UsbClassDevicePath2->DeviceSubClass) &&
+                (UsbClassDevicePath1->DeviceProtocol != 0xFF) && (UsbClassDevicePath1->DeviceProtocol == UsbClassDevicePath2->DeviceProtocol))
+            {
+              *DeviceHandle = UsbIoBuffer[Index];
+              // Add the additional original Device Path Nodes (eg: FilePath Device Path Node) to the new Device Path
+              *NewDevicePath = AppendDevicePath (UsbIoDevicePath, NextDevicePathNode(RemovableDevicePath));
+              return EFI_SUCCESS;
+            }
+          }
         }
-        Str++;
-    }
+        TmpDevicePath = NextDevicePathNode (TmpDevicePath);
+      }
 
-    if (*Str == L'\0') {
-        return NULL;
-    } else {
-        return Str;
     }
+  }
+
+  return EFI_NOT_FOUND;
+}
+
+BOOLEAN
+BdsIsRemovableHd (
+  IN  EFI_DEVICE_PATH*  DevicePath
+  )
+{
+  return IS_DEVICE_PATH_NODE(DevicePath, MEDIA_DEVICE_PATH, MEDIA_HARDDRIVE_DP);
 }
 
 EFI_STATUS
-BdsLoadDevicePath(
-    IN  EFI_DEVICE_PATH_PROTOCOL* DevicePath,
-    OUT EFI_HANDLE                *Handle
-) {
-    EFI_DEVICE_PATH_PROTOCOL    *RemainingDevicePath;
-    EFI_STATUS                  Status;
-
-    if ((DevicePath == NULL) || (Handle == NULL)) {
-        return EFI_INVALID_PARAMETER;
-    }
+BdsGetDeviceHd (
+  IN  EFI_DEVICE_PATH*  RemovableDevicePath,
+  OUT EFI_HANDLE*       DeviceHandle,
+  OUT EFI_DEVICE_PATH** NewDevicePath
+  )
+{
+  EFI_STATUS                    Status;
+  UINTN                         Index;
+  UINTN                         PartitionHandleCount;
+  EFI_HANDLE                    *PartitionBuffer;
+  EFI_DEVICE_PATH*              PartitionDevicePath;
+  EFI_DEVICE_PATH*              TmpDevicePath;
+  HARDDRIVE_DEVICE_PATH*        HardDriveDevicePath1;
+  HARDDRIVE_DEVICE_PATH*        HardDriveDevicePath2;
 
-    do {
-        RemainingDevicePath = DevicePath;
-        // The LocateDevicePath() function locates all devices on DevicePath that support Protocol and returns
-        // the handle to the device that is closest to DevicePath. On output, the device path pointer is modified
-        // to point to the remaining part of the device path
-        Status = gBS->LocateDevicePath(&gEfiDevicePathProtocolGuid,&RemainingDevicePath,Handle);
-        if (!EFI_ERROR (Status)) {
-            // Recursive = FALSE: We do not want to start all the device tree
-            Status = gBS->ConnectController (*Handle, NULL, RemainingDevicePath, FALSE);
-        }
+  // Get all the DiskIo handles
+  PartitionHandleCount = 0;
+  Status = gBS->LocateHandleBuffer (ByProtocol, &gEfiDiskIoProtocolGuid, NULL, &PartitionHandleCount, &PartitionBuffer);
+  if (EFI_ERROR(Status) || (PartitionHandleCount == 0)) {
+    return Status;
+  }
 
-        // We need to check if RemainingDevicePath does not point on the last node. Otherwise, calling
-        // NextDevicePathNode() will return an undetermined Device Path Node
-        if (!IsDevicePathEnd (RemainingDevicePath)) {
-            RemainingDevicePath = NextDevicePathNode (RemainingDevicePath);
+  // Check if one of the handles matches the Hard Disk Description
+  for (Index = 0; Index < PartitionHandleCount; Index++) {
+    Status = gBS->HandleProtocol (PartitionBuffer[Index], &gEfiDevicePathProtocolGuid, (VOID *) &PartitionDevicePath);
+    if (!EFI_ERROR(Status)) {
+      TmpDevicePath = PartitionDevicePath;
+      while (!IsDevicePathEnd (TmpDevicePath)) {
+        // Check if the Device Path node is a HD Removable device Path node
+        if (BdsIsRemovableHd (TmpDevicePath)) {
+          HardDriveDevicePath1 = (HARDDRIVE_DEVICE_PATH*)RemovableDevicePath;
+          HardDriveDevicePath2 = (HARDDRIVE_DEVICE_PATH*)TmpDevicePath;
+          if ((HardDriveDevicePath1->SignatureType == HardDriveDevicePath2->SignatureType) &&
+              (CompareGuid ((EFI_GUID *)HardDriveDevicePath1->Signature,(EFI_GUID *)HardDriveDevicePath2->Signature) == TRUE) &&
+              (HardDriveDevicePath1->PartitionNumber == HardDriveDevicePath2->PartitionNumber))
+          {
+            *DeviceHandle = PartitionBuffer[Index];
+            // Add the additional original Device Path Nodes (eg: FilePath Device Path Node) to the new Device Path
+            *NewDevicePath = AppendDevicePath (PartitionDevicePath, NextDevicePathNode(RemovableDevicePath));
+            return EFI_SUCCESS;
+          }
         }
-    } while (!EFI_ERROR (Status) && !IsDevicePathEnd (RemainingDevicePath));
+        TmpDevicePath = NextDevicePathNode (TmpDevicePath);
+      }
 
-    if (!EFI_ERROR (Status)) {
-        // Now, we have got the whole Device Path connected, call again ConnectController to ensure all the supported Driver
-        // Binding Protocol are connected (such as DiskIo and SimpleFileSystem)
-        RemainingDevicePath = DevicePath;
-        Status = gBS->LocateDevicePath(&gEfiDevicePathProtocolGuid,&RemainingDevicePath,Handle);
-        if (!EFI_ERROR (Status)) {
-            Status = gBS->ConnectController (*Handle, NULL, RemainingDevicePath, FALSE);
-            if (EFI_ERROR (Status)) {
-                // If the last node is a Memory Map Device Path just return EFI_SUCCESS.
-                if ((RemainingDevicePath->Type == HARDWARE_DEVICE_PATH) && (RemainingDevicePath->SubType == HW_MEMMAP_DP)) {
-                    Status = EFI_SUCCESS;
-                }
-            }
-        }
-    } else if (IsDevicePathEnd (RemainingDevicePath)) {
-        // Case when the DevicePath contains a MemoryMap Device Path Node and all drivers are connected.
-        // Ensure the Device Path exists
-        RemainingDevicePath = DevicePath;
-        Status = gBS->LocateDevicePath(&gEfiDevicePathProtocolGuid,&RemainingDevicePath,Handle);
     }
+  }
 
-    return Status;
+  return EFI_NOT_FOUND;
 }
 
+/*BOOLEAN
+BdsIsRemovableCdrom (
+  IN  EFI_DEVICE_PATH*  DevicePath
+  )
+{
+  return IS_DEVICE_PATH_NODE(DevicePath, MEDIA_DEVICE_PATH, MEDIA_CDROM_DP);
+}
 
 EFI_STATUS
-BdsLoadFilePath (
-    IN  CONST CHAR16        *DeviceFilePath,
-    OUT BDS_FILE            *File
-) {
-    EFI_DEVICE_PATH_PROTOCOL            *DevicePath;
-    EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL  *EfiDevicePathFromTextProtocol;
-    EFI_STATUS Status;
-    EFI_HANDLE Handle;
-    UINTN                               NumberDevicePathNode;
-    CHAR16                              *FilePath;
-
-    //Do a sanity check on the Device file path
-    if (DeviceFilePath == NULL) {
-        return EFI_INVALID_PARAMETER;
+BdsGetDeviceCdrom (
+  IN  EFI_DEVICE_PATH*  RemovableDevicePath,
+  OUT EFI_HANDLE*       DeviceHandle,
+  OUT EFI_DEVICE_PATH** DevicePath
+  )
+{
+  ASSERT(0);
+  return EFI_UNSUPPORTED;
+}*/
+
+typedef BOOLEAN
+(*BDS_IS_REMOVABLE) (
+  IN  EFI_DEVICE_PATH*  DevicePath
+  );
+
+typedef EFI_STATUS
+(*BDS_GET_DEVICE) (
+  IN  EFI_DEVICE_PATH*  RemovableDevicePath,
+  OUT EFI_HANDLE*       DeviceHandle,
+  OUT EFI_DEVICE_PATH** DevicePath
+  );
+
+typedef struct {
+  BDS_IS_REMOVABLE    IsRemovable;
+  BDS_GET_DEVICE      GetDevice;
+} BDS_REMOVABLE_DEVICE_SUPPORT;
+
+BDS_REMOVABLE_DEVICE_SUPPORT  RemovableDeviceSupport[] = {
+  { BdsIsRemovableUsb, BdsGetDeviceUsb },
+  { BdsIsRemovableHd, BdsGetDeviceHd },
+  //{ BdsIsRemovableCdrom, BdsGetDeviceCdrom }
+};
+
+STATIC
+BOOLEAN
+IsRemovableDevice (
+  IN  EFI_DEVICE_PATH*  DevicePath
+  )
+{
+  UINTN             Index;
+  EFI_DEVICE_PATH*  TmpDevicePath;
+
+  TmpDevicePath = DevicePath;
+  while (!IsDevicePathEnd (TmpDevicePath)) {
+    for (Index = 0; Index < sizeof(RemovableDeviceSupport) / sizeof(BDS_REMOVABLE_DEVICE_SUPPORT); Index++) {
+      if (RemovableDeviceSupport[Index].IsRemovable(TmpDevicePath)) {
+        return TRUE;
+      }
     }
+    TmpDevicePath = NextDevicePathNode (TmpDevicePath);
+  }
+
+  return FALSE;
+}
 
-    //  Convert the Device Path String into Device Path Protocol
-    Status = gBS->LocateProtocol(&gEfiDevicePathFromTextProtocolGuid, NULL, (VOID **)&EfiDevicePathFromTextProtocol);
-    ASSERT_EFI_ERROR(Status);
-    DevicePath = EfiDevicePathFromTextProtocol->ConvertTextToDevicePath(DeviceFilePath);
+STATIC
+EFI_STATUS
+TryRemovableDevice (
+  IN  EFI_DEVICE_PATH*  DevicePath,
+  OUT EFI_HANDLE*       DeviceHandle,
+  OUT EFI_DEVICE_PATH** NewDevicePath
+  )
+{
+  EFI_STATUS        Status;
+  UINTN             Index;
+  EFI_DEVICE_PATH*  TmpDevicePath;
+  BDS_REMOVABLE_DEVICE_SUPPORT* RemovableDevice;
+  EFI_DEVICE_PATH* RemovableDevicePath;
+  BOOLEAN         RemovableFound;
 
-    //Do a sanity check on the Device Path
-    if (DevicePath == NULL) {
-        return EFI_INVALID_PARAMETER;
+  RemovableFound = FALSE;
+  TmpDevicePath = DevicePath;
+  while (!IsDevicePathEnd (TmpDevicePath) && !RemovableFound) {
+    for (Index = 0; Index < sizeof(RemovableDeviceSupport) / sizeof(BDS_REMOVABLE_DEVICE_SUPPORT); Index++) {
+      RemovableDevice = &RemovableDeviceSupport[Index];
+      if (RemovableDevice->IsRemovable(TmpDevicePath)) {
+        RemovableDevicePath = TmpDevicePath;
+        RemovableFound = TRUE;
+        break;
+      }
     }
+    TmpDevicePath = NextDevicePathNode (TmpDevicePath);
+  }
 
-    // Count the number of DevicePath Node
-    NumberDevicePathNode = NumberNodeFromDevicePath(DevicePath);
-    // Extract the FilePath from the Device Path
-    FilePath = BdsExtractFilePathFromDevicePath(DeviceFilePath,NumberDevicePathNode);
+  if (!RemovableFound) {
+    return EFI_NOT_FOUND;
+  }
 
-    Status = BdsLoadDevicePath(DevicePath,&Handle);
-    if (EFI_ERROR (Status)) {
-        return Status;
+  // Search into the current started drivers
+  Status = RemovableDevice->GetDevice (RemovableDevicePath, DeviceHandle, NewDevicePath);
+  if (Status == EFI_NOT_FOUND) {
+    // Connect all the drivers
+    BdsConnectAllDrivers ();
+
+    // Search again into all the drivers
+    Status = RemovableDevice->GetDevice (RemovableDevicePath, DeviceHandle, NewDevicePath);
+  }
+
+  return Status;
+}
+
+EFI_STATUS
+BdsConnectDevicePath (
+  IN  EFI_DEVICE_PATH_PROTOCOL* DevicePath,
+  OUT EFI_HANDLE                *Handle,
+  OUT EFI_DEVICE_PATH_PROTOCOL  **RemainingDevicePath
+  )
+{
+  EFI_DEVICE_PATH*            Remaining;
+  EFI_DEVICE_PATH*            NewDevicePath;
+  EFI_STATUS                  Status;
+
+  if ((DevicePath == NULL) || (Handle == NULL)) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  do {
+    Remaining = DevicePath;
+    // The LocateDevicePath() function locates all devices on DevicePath that support Protocol and returns
+    // the handle to the device that is closest to DevicePath. On output, the device path pointer is modified
+    // to point to the remaining part of the device path
+    Status = gBS->LocateDevicePath (&gEfiDevicePathProtocolGuid, &Remaining, Handle);
+    if (!EFI_ERROR (Status)) {
+      // Recursive = FALSE: We do not want to start all the device tree
+      Status = gBS->ConnectController (*Handle, NULL, Remaining, FALSE);
     }
 
-    //If FilePath == NULL then let consider if a MemoryMap Device Path
-    if (FilePath == NULL) {
-        // Check if the Node is a MemoryMap Device Path
-        Status = BdsLoadFileFromMemMap(Handle,DevicePath,File);
-    } else {
-        Status = BdsLoadFileFromSimpleFileSystem(Handle,FilePath,File);
-        if (EFI_ERROR (Status)) {
-            Status = BdsLoadFileFromFirmwareVolume(Handle,FilePath,EFI_FV_FILETYPE_ALL,File);
+    /*// We need to check if RemainingDevicePath does not point on the last node. Otherwise, calling
+    // NextDevicePathNode() will return an undetermined Device Path Node
+    if (!IsDevicePathEnd (RemainingDevicePath)) {
+      RemainingDevicePath = NextDevicePathNode (RemainingDevicePath);
+    }*/
+  } while (!EFI_ERROR (Status) && !IsDevicePathEnd (Remaining));
+
+  if (!EFI_ERROR (Status)) {
+    // Now, we have got the whole Device Path connected, call again ConnectController to ensure all the supported Driver
+    // Binding Protocol are connected (such as DiskIo and SimpleFileSystem)
+    Remaining = DevicePath;
+    Status = gBS->LocateDevicePath(&gEfiDevicePathProtocolGuid,&Remaining,Handle);
+    if (!EFI_ERROR (Status)) {
+      Status = gBS->ConnectController (*Handle, NULL, Remaining, FALSE);
+      if (EFI_ERROR (Status)) {
+        // If the last node is a Memory Map Device Path just return EFI_SUCCESS.
+        if ((Remaining->Type == HARDWARE_DEVICE_PATH) && (Remaining->SubType == HW_MEMMAP_DP)) {
+            Status = EFI_SUCCESS;
         }
+      }
     }
+  } else if (!IsDevicePathEnd (Remaining) && !IsRemovableDevice (Remaining)) {
+
+    /*// If the remaining Device Path is a FilePath or MemoryMap then we consider the Device Path has been loaded correctly
+    if ((Remaining->Type == MEDIA_DEVICE_PATH) && (Remaining->SubType == MEDIA_FILEPATH_DP)) {
+      Status = EFI_SUCCESS;
+    } else if ((Remaining->Type == HARDWARE_DEVICE_PATH) && (Remaining->SubType == HW_MEMMAP_DP)) {
+      Status = EFI_SUCCESS;
+    }*/
 
+    //TODO: Should we just return success and leave the caller decide if it is the expected RemainingPath
+    Status = EFI_SUCCESS;
+  } else {
+    Status = TryRemovableDevice (DevicePath, Handle, &NewDevicePath);
     if (!EFI_ERROR (Status)) {
-        File->DevicePath = DevicePath;
+      return BdsConnectDevicePath (NewDevicePath, Handle, RemainingDevicePath);
+    }
+  }
+
+  if (RemainingDevicePath) {
+    *RemainingDevicePath = Remaining;
+  }
+
+  return Status;
+}
+
+BOOLEAN
+BdsFileSystemSupport (
+  IN EFI_DEVICE_PATH *DevicePath,
+  IN EFI_HANDLE Handle,
+  IN EFI_DEVICE_PATH *RemainingDevicePath
+  )
+{
+  EFI_STATUS  Status;
+  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL     *FsProtocol;
+
+  Status = gBS->HandleProtocol (Handle,&gEfiSimpleFileSystemProtocolGuid, (VOID **)&FsProtocol);
+
+  return (!EFI_ERROR(Status) && IS_DEVICE_PATH_NODE(RemainingDevicePath,MEDIA_DEVICE_PATH,MEDIA_FILEPATH_DP));
+}
+
+EFI_STATUS
+BdsFileSystemLoadImage (
+  IN     EFI_DEVICE_PATH *DevicePath,
+  IN     EFI_HANDLE Handle,
+  IN     EFI_DEVICE_PATH *RemainingDevicePath,
+  IN     EFI_ALLOCATE_TYPE     Type,
+  IN OUT EFI_PHYSICAL_ADDRESS* Image,
+  OUT    UINTN                 *ImageSize
+  )
+{
+  FILEPATH_DEVICE_PATH*             FilePathDevicePath;
+  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL     *FsProtocol;
+  EFI_FILE_PROTOCOL                   *Fs;
+  EFI_STATUS Status;
+  EFI_FILE_INFO       *FileInfo;
+  EFI_FILE_PROTOCOL   *File;
+  UINTN               Size;
+
+  ASSERT (IS_DEVICE_PATH_NODE(RemainingDevicePath,MEDIA_DEVICE_PATH,MEDIA_FILEPATH_DP));
+
+  FilePathDevicePath = (FILEPATH_DEVICE_PATH*)RemainingDevicePath;
+
+  Status = gBS->HandleProtocol(Handle,&gEfiSimpleFileSystemProtocolGuid, (VOID **)&FsProtocol);
+  if (EFI_ERROR(Status)) {
+    return Status;
+  }
+
+  //Try to Open the volume and get root directory
+  Status = FsProtocol->OpenVolume (FsProtocol, &Fs);
+  if (EFI_ERROR(Status)) {
+    return Status;
+  }
+
+  File = NULL;
+  Status = Fs->Open(Fs, &File, FilePathDevicePath->PathName, EFI_FILE_MODE_READ, 0);
+
+  Size = 0;
+  File->GetInfo(File, &gEfiFileInfoGuid, &Size, NULL);
+  FileInfo = AllocatePool (Size);
+  Status = File->GetInfo(File, &gEfiFileInfoGuid, &Size, FileInfo);
+  if (EFI_ERROR(Status)) {
+    return Status;
+  }
+
+  // Get the file size
+  Size = FileInfo->FileSize;
+  if (ImageSize) {
+    *ImageSize = Size;
+  }
+  FreePool(FileInfo);
+
+  Status = gBS->AllocatePages (Type, EfiBootServicesCode, EFI_SIZE_TO_PAGES(Size),Image);
+  if (!EFI_ERROR(Status)) {
+    Status = File->Read (File, &Size, (VOID*)(UINTN)(*Image));
+  }
+
+  return Status;
+}
+
+BOOLEAN
+BdsMemoryMapSupport (
+  IN EFI_DEVICE_PATH *DevicePath,
+  IN EFI_HANDLE Handle,
+  IN EFI_DEVICE_PATH *RemainingDevicePath
+  )
+{
+  return IS_DEVICE_PATH_NODE(RemainingDevicePath,HARDWARE_DEVICE_PATH,HW_MEMMAP_DP);
+}
+
+EFI_STATUS
+BdsMemoryMapLoadImage (
+  IN     EFI_DEVICE_PATH *DevicePath,
+  IN     EFI_HANDLE Handle,
+  IN     EFI_DEVICE_PATH *RemainingDevicePath,
+  IN     EFI_ALLOCATE_TYPE     Type,
+  IN OUT EFI_PHYSICAL_ADDRESS* Image,
+  OUT    UINTN                 *ImageSize
+  )
+{
+  EFI_STATUS            Status;
+  MEMMAP_DEVICE_PATH*   MemMapPathDevicePath;
+  UINTN                 Size;
+
+  ASSERT (IS_DEVICE_PATH_NODE(RemainingDevicePath,HARDWARE_DEVICE_PATH,HW_MEMMAP_DP));
+
+  MemMapPathDevicePath = (MEMMAP_DEVICE_PATH*)RemainingDevicePath;
+
+  Size = MemMapPathDevicePath->EndingAddress - MemMapPathDevicePath->StartingAddress;
+  if (Size == 0) {
+      return EFI_INVALID_PARAMETER;
+  }
+
+  Status = gBS->AllocatePages (Type, EfiBootServicesCode, EFI_SIZE_TO_PAGES(Size),Image);
+  if (!EFI_ERROR(Status)) {
+    CopyMem ((VOID*)(UINTN)(*Image), (CONST VOID*)(UINTN)MemMapPathDevicePath->StartingAddress, Size);
+
+    if (ImageSize != NULL) {
+        *ImageSize = Size;
     }
+  }
 
+  return Status;
+}
+
+BOOLEAN
+BdsFirmwareVolumeSupport (
+  IN EFI_DEVICE_PATH *DevicePath,
+  IN EFI_HANDLE Handle,
+  IN EFI_DEVICE_PATH *RemainingDevicePath
+  )
+{
+  return IS_DEVICE_PATH_NODE(RemainingDevicePath, MEDIA_DEVICE_PATH, MEDIA_PIWG_FW_FILE_DP);
+}
+
+EFI_STATUS
+BdsFirmwareVolumeLoadImage (
+  IN     EFI_DEVICE_PATH *DevicePath,
+  IN     EFI_HANDLE Handle,
+  IN     EFI_DEVICE_PATH *RemainingDevicePath,
+  IN     EFI_ALLOCATE_TYPE     Type,
+  IN OUT EFI_PHYSICAL_ADDRESS* Image,
+  OUT    UINTN                 *ImageSize
+  )
+{
+  EFI_STATUS            Status;
+  EFI_FIRMWARE_VOLUME2_PROTOCOL     *FwVol;
+  EFI_GUID                          *FvNameGuid;
+  EFI_SECTION_TYPE                  SectionType;
+  EFI_FV_FILETYPE                   FvType;
+  EFI_FV_FILE_ATTRIBUTES            Attrib;
+  UINT32                            AuthenticationStatus;
+  VOID* ImageBuffer;
+
+  ASSERT (IS_DEVICE_PATH_NODE(RemainingDevicePath, MEDIA_DEVICE_PATH, MEDIA_PIWG_FW_FILE_DP));
+
+  Status = gBS->HandleProtocol(Handle,&gEfiFirmwareVolume2ProtocolGuid, (VOID **)&FwVol);
+  if (EFI_ERROR(Status)) {
     return Status;
+  }
+
+  FvNameGuid = EfiGetNameGuidFromFwVolDevicePathNode ((CONST MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *)RemainingDevicePath);
+  if (FvNameGuid == NULL) {
+    Status = EFI_INVALID_PARAMETER;
+  }
+
+  SectionType = EFI_SECTION_PE32;
+  AuthenticationStatus = 0;
+  //Note: ReadSection at the opposite of ReadFile does not allow to pass ImageBuffer == NULL to get the size of the file.
+  ImageBuffer = NULL;
+  Status = FwVol->ReadSection (
+                    FwVol,
+                    FvNameGuid,
+                    SectionType,
+                    0,
+                    &ImageBuffer,
+                    ImageSize,
+                    &AuthenticationStatus
+                    );
+  if (!EFI_ERROR (Status)) {
+#if 0
+    // In case the buffer has some address requirements, we must copy the buffer to a buffer following the requirements
+    if (Type != AllocateAnyPages) {
+      Status = gBS->AllocatePages (Type, EfiBootServicesCode, EFI_SIZE_TO_PAGES(*ImageSize),Image);
+      if (!EFI_ERROR(Status)) {
+        CopyMem ((VOID*)(UINTN)(*Image), ImageBuffer, *ImageSize);
+        FreePool (ImageBuffer);
+      }
+    }
+#else
+    // We must copy the buffer into a page allocations. Otherwise, the caller could call gBS->FreePages() on the pool allocation
+    Status = gBS->AllocatePages (Type, EfiBootServicesCode, EFI_SIZE_TO_PAGES(*ImageSize), Image);
+    if (!EFI_ERROR(Status)) {
+      CopyMem ((VOID*)(UINTN)(*Image), ImageBuffer, *ImageSize);
+      FreePool (ImageBuffer);
+    }
+#endif
+  } else {
+    // Try a raw file, since a PE32 SECTION does not exist
+    Status = FwVol->ReadFile (
+                        FwVol,
+                        FvNameGuid,
+                        NULL,
+                        ImageSize,
+                        &FvType,
+                        &Attrib,
+                        &AuthenticationStatus
+                        );
+    if (!EFI_ERROR(Status)) {
+      Status = gBS->AllocatePages (Type, EfiBootServicesCode, EFI_SIZE_TO_PAGES(*ImageSize),Image);
+      if (!EFI_ERROR(Status)) {
+        Status = FwVol->ReadFile (
+                                FwVol,
+                                FvNameGuid,
+                                (VOID*)(UINTN)(*Image),
+                                ImageSize,
+                                &FvType,
+                                &Attrib,
+                                &AuthenticationStatus
+                                );
+      }
+    }
+  }
+  return Status;
 }
 
-EFI_STATUS BdsCopyRawFileToRuntimeMemory(
-    IN  BDS_FILE            *File,
-    OUT VOID                **FileImage,
-    OUT UINTN               *FileSize
-) {
-    if (File == NULL) {
-        return EFI_INVALID_PARAMETER;
+BOOLEAN
+BdsPxeSupport (
+  IN EFI_DEVICE_PATH*           DevicePath,
+  IN EFI_HANDLE                 Handle,
+  IN EFI_DEVICE_PATH*           RemainingDevicePath
+  )
+{
+  EFI_STATUS                  Status;
+  EFI_PXE_BASE_CODE_PROTOCOL* PxeBcProtocol;
+
+  if (!IsDevicePathEnd(RemainingDevicePath)) {
+    return FALSE;
+  }
+
+  Status = gBS->HandleProtocol (Handle, &gEfiPxeBaseCodeProtocolGuid, (VOID **)&PxeBcProtocol);
+  if (EFI_ERROR (Status)) {
+    return FALSE;
+  } else {
+    return TRUE;
+  }
+}
+
+EFI_STATUS
+BdsPxeLoadImage (
+  IN     EFI_DEVICE_PATH*       DevicePath,
+  IN     EFI_HANDLE             Handle,
+  IN     EFI_DEVICE_PATH*       RemainingDevicePath,
+  IN     EFI_ALLOCATE_TYPE      Type,
+  IN OUT EFI_PHYSICAL_ADDRESS   *Image,
+  OUT    UINTN                  *ImageSize
+  )
+{
+  EFI_STATUS              Status;
+  EFI_LOAD_FILE_PROTOCOL  *LoadFileProtocol;
+  UINTN                   BufferSize;
+
+  // Get Load File Protocol attached to the PXE protocol
+  Status = gBS->HandleProtocol (Handle, &gEfiLoadFileProtocolGuid, (VOID **)&LoadFileProtocol);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  Status = LoadFileProtocol->LoadFile (LoadFileProtocol, DevicePath, TRUE, &BufferSize, NULL);
+  if (Status == EFI_BUFFER_TOO_SMALL) {
+    Status = gBS->AllocatePages (Type, EfiBootServicesCode, EFI_SIZE_TO_PAGES(BufferSize), Image);
+    if (EFI_ERROR(Status)) {
+      return Status;
     }
 
-    if (File->Type == BDS_FILETYPE_FS) {
-        return BdsCopyRawFileToRuntimeMemoryFS(File->File.Fs.Handle,FileImage,FileSize);
-    } else if (File->Type == BDS_FILETYPE_FV) {
-        return BdsCopyRawFileToRuntimeMemoryFV(&(File->File.Fv),FileImage,FileSize);
-    } else if (File->Type == BDS_FILETYPE_MEM) {
-        return BdsCopyRawFileToRuntimeMemoryMemMap(&(File->File.Mem),FileImage,FileSize);
-    } else {
-        return EFI_INVALID_PARAMETER;
+    Status = LoadFileProtocol->LoadFile (LoadFileProtocol, DevicePath, TRUE, &BufferSize, (VOID*)(UINTN)(*Image));
+    if (!EFI_ERROR(Status) && (ImageSize != NULL)) {
+      *ImageSize = BufferSize;
     }
+  }
+
+  return Status;
+}
+
+BOOLEAN
+BdsTftpSupport (
+  IN EFI_DEVICE_PATH*           DevicePath,
+  IN EFI_HANDLE                 Handle,
+  IN EFI_DEVICE_PATH*           RemainingDevicePath
+  )
+{
+  EFI_STATUS  Status;
+  EFI_DEVICE_PATH  *NextDevicePath;
+  EFI_PXE_BASE_CODE_PROTOCOL  *PxeBcProtocol;
+
+  // Validate the Remaining Device Path
+  if (IsDevicePathEnd(RemainingDevicePath)) {
+    return FALSE;
+  }
+  if (!IS_DEVICE_PATH_NODE(RemainingDevicePath,MESSAGING_DEVICE_PATH,MSG_IPv4_DP) &&
+      !IS_DEVICE_PATH_NODE(RemainingDevicePath,MESSAGING_DEVICE_PATH,MSG_IPv6_DP)) {
+    return FALSE;
+  }
+  NextDevicePath = NextDevicePathNode (RemainingDevicePath);
+  if (IsDevicePathEnd(NextDevicePath)) {
+    return FALSE;
+  }
+  if (!IS_DEVICE_PATH_NODE(NextDevicePath,MEDIA_DEVICE_PATH,MEDIA_FILEPATH_DP)) {
+    return FALSE;
+  }
+
+  Status = gBS->HandleProtocol (Handle, &gEfiPxeBaseCodeProtocolGuid, (VOID **)&PxeBcProtocol);
+  if (EFI_ERROR (Status)) {
+    return FALSE;
+  } else {
+    return TRUE;
+  }
+}
+
+EFI_STATUS
+BdsTftpLoadImage (
+  IN     EFI_DEVICE_PATH*       DevicePath,
+  IN     EFI_HANDLE             Handle,
+  IN     EFI_DEVICE_PATH*       RemainingDevicePath,
+  IN     EFI_ALLOCATE_TYPE      Type,
+  IN OUT EFI_PHYSICAL_ADDRESS   *Image,
+  OUT    UINTN                  *ImageSize
+  )
+{
+  EFI_STATUS                  Status;
+  EFI_PXE_BASE_CODE_PROTOCOL  *Pxe;
+  UINT64                      TftpBufferSize;
+  VOID*                       TftpBuffer;
+  EFI_IP_ADDRESS              ServerIp;
+  IPv4_DEVICE_PATH*           IPv4DevicePathNode;
+  FILEPATH_DEVICE_PATH*       FilePathDevicePath;
+  EFI_IP_ADDRESS              LocalIp;
+
+  ASSERT(IS_DEVICE_PATH_NODE(RemainingDevicePath,MESSAGING_DEVICE_PATH,MSG_IPv4_DP));
+
+  IPv4DevicePathNode = (IPv4_DEVICE_PATH*)RemainingDevicePath;
+  FilePathDevicePath = (FILEPATH_DEVICE_PATH*)(IPv4DevicePathNode + 1);
+
+  Status = gBS->LocateProtocol (&gEfiPxeBaseCodeProtocolGuid, NULL, (VOID **)&Pxe);
+  if (EFI_ERROR(Status)) {
+    return Status;
+  }
+
+  Status = Pxe->Start (Pxe, FALSE);
+  if (EFI_ERROR(Status) && (Status != EFI_ALREADY_STARTED)) {
+    return Status;
+  }
+
+  if (!IPv4DevicePathNode->StaticIpAddress) {
+    Status = Pxe->Dhcp(Pxe, TRUE);
+  } else {
+    CopyMem (&LocalIp.v4, &IPv4DevicePathNode->LocalIpAddress, sizeof (EFI_IPv4_ADDRESS));
+    Status = Pxe->SetStationIp (Pxe, &LocalIp, NULL);
+  }
+  if (EFI_ERROR(Status)) {
+    return Status;
+  }
+
+  CopyMem (&ServerIp.v4, &IPv4DevicePathNode->RemoteIpAddress, sizeof (EFI_IPv4_ADDRESS));
+
+  Status = Pxe->Mtftp (
+                  Pxe,
+                  EFI_PXE_BASE_CODE_TFTP_GET_FILE_SIZE,
+                  NULL,
+                  FALSE,
+                  &TftpBufferSize,
+                  NULL,
+                  &ServerIp,
+                  (UINT8 *)FilePathDevicePath->PathName,
+                  NULL,
+                  TRUE
+                  );
+  if (EFI_ERROR(Status)) {
+    return Status;
+  }
+
+  // Allocate a buffer to hold the whole file.
+  TftpBuffer = AllocatePool(TftpBufferSize);
+  if (TftpBuffer == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  Status = Pxe->Mtftp (
+                  Pxe,
+                  EFI_PXE_BASE_CODE_TFTP_READ_FILE,
+                  TftpBuffer,
+                  FALSE,
+                  &TftpBufferSize,
+                  NULL,
+                  &ServerIp,
+                  (UINT8 *)FilePathDevicePath->PathName,
+                  NULL,
+                  FALSE
+                  );
+  if (EFI_ERROR(Status)) {
+    FreePool(TftpBuffer);
+  } else if (ImageSize != NULL) {
+    *ImageSize = (UINTN)TftpBufferSize;
+  }
+
+  return Status;
+}
+
+BDS_FILE_LOADER FileLoaders[] = {
+    { BdsFileSystemSupport, BdsFileSystemLoadImage },
+    { BdsFirmwareVolumeSupport, BdsFirmwareVolumeLoadImage },
+    //{ BdsLoadFileSupport, BdsLoadFileLoadImage },
+    { BdsMemoryMapSupport, BdsMemoryMapLoadImage },
+    { BdsPxeSupport, BdsPxeLoadImage },
+    { BdsTftpSupport, BdsTftpLoadImage },
+    { NULL, NULL }
+};
+
+EFI_STATUS
+BdsLoadImage (
+  IN     EFI_DEVICE_PATH       *DevicePath,
+  IN     EFI_ALLOCATE_TYPE     Type,
+  IN OUT EFI_PHYSICAL_ADDRESS* Image,
+  OUT    UINTN                 *FileSize
+  )
+{
+  EFI_STATUS      Status;
+  EFI_HANDLE      Handle;
+  EFI_DEVICE_PATH *RemainingDevicePath;
+  BDS_FILE_LOADER*  FileLoader;
+
+  Status = BdsConnectDevicePath (DevicePath, &Handle, &RemainingDevicePath);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  FileLoader = FileLoaders;
+  while (FileLoader->Support != NULL) {
+    if (FileLoader->Support (DevicePath, Handle, RemainingDevicePath)) {
+      return FileLoader->LoadImage (DevicePath, Handle, RemainingDevicePath, Type, Image, FileSize);
+    }
+    FileLoader++;
+  }
+
+  return EFI_UNSUPPORTED;
+}
+
+EFI_STATUS
+BdsStartEfiApplication (
+  IN EFI_HANDLE                  ParentImageHandle,
+  IN EFI_DEVICE_PATH_PROTOCOL    *DevicePath
+  )
+{
+  EFI_STATUS                   Status;
+  EFI_HANDLE                   ImageHandle;
+  EFI_PHYSICAL_ADDRESS         BinaryBuffer;
+  UINTN                        BinarySize;
+
+  // Find the nearest supported file loader
+  Status = BdsLoadImage (DevicePath, AllocateAnyPages,&BinaryBuffer,&BinarySize);
+  if (EFI_ERROR(Status)) {
+    return Status;
+  }
+
+  // Load the image from the Buffer with Boot Services function
+  Status = gBS->LoadImage (TRUE, ParentImageHandle, DevicePath, (VOID*)(UINTN)BinaryBuffer, BinarySize, &ImageHandle);
+  if (EFI_ERROR(Status)) {
+    return Status;
+  }
+
+  // Before calling the image, enable the Watchdog Timer for  the 5 Minute period
+  gBS->SetWatchdogTimer (5 * 60, 0x0000, 0x00, NULL);
+  // Start the image
+  Status = gBS->StartImage (ImageHandle, NULL, NULL);
+  // Clear the Watchdog Timer after the image returns
+  gBS->SetWatchdogTimer (0x0000, 0x0000, 0x0000, NULL);
+
+  return Status;
 }