[mirror_edk2.git] / ArmPlatformPkg / Bds / BootOptionSupport.c

/** @file\r
*\r
*  Copyright (c) 2011-2014, ARM Limited. All rights reserved.\r
*\r
*  This program and the accompanying materials\r
*  are licensed and made available under the terms and conditions of the BSD License\r
*  which accompanies this distribution.  The full text of the license may be found at\r
*  http://opensource.org/licenses/bsd-license.php\r
*\r
*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
*\r
**/\r
\r
#include "BdsInternal.h"\r
\r
#include <Library/NetLib.h>\r
\r
#include <Protocol/BlockIo.h>\r
#include <Protocol/DevicePathToText.h>\r
#include <Protocol/PxeBaseCode.h>\r
#include <Protocol/SimpleFileSystem.h>\r
#include <Protocol/SimpleNetwork.h>\r
\r
#include <Guid/FileSystemInfo.h>\r
\r
#define IS_DEVICE_PATH_NODE(node,type,subtype) (((node)->Type == (type)) && ((node)->SubType == (subtype)))\r
\r
EFI_STATUS\r
BdsLoadOptionFileSystemList (\r
  IN OUT LIST_ENTRY* BdsLoadOptionList\r
  );\r
\r
EFI_STATUS\r
BdsLoadOptionFileSystemCreateDevicePath (\r
  IN CHAR16*                    FileName,\r
  OUT EFI_DEVICE_PATH_PROTOCOL  **DevicePathNodes\r
  );\r
\r
EFI_STATUS\r
BdsLoadOptionFileSystemUpdateDevicePath (\r
  IN EFI_DEVICE_PATH            *OldDevicePath,\r
  IN CHAR16*                    FileName,\r
  OUT EFI_DEVICE_PATH_PROTOCOL  **NewDevicePath\r
  );\r
\r
BOOLEAN\r
BdsLoadOptionFileSystemIsSupported (\r
  IN  EFI_DEVICE_PATH           *DevicePath\r
  );\r
\r
EFI_STATUS\r
BdsLoadOptionMemMapList (\r
  IN OUT LIST_ENTRY* BdsLoadOptionList\r
  );\r
\r
EFI_STATUS\r
BdsLoadOptionMemMapCreateDevicePath (\r
  IN CHAR16*                    FileName,\r
  OUT EFI_DEVICE_PATH_PROTOCOL  **DevicePathNodes\r
  );\r
\r
EFI_STATUS\r
BdsLoadOptionMemMapUpdateDevicePath (\r
  IN EFI_DEVICE_PATH            *OldDevicePath,\r
  IN CHAR16*                    FileName,\r
  OUT EFI_DEVICE_PATH_PROTOCOL  **NewDevicePath\r
  );\r
\r
BOOLEAN\r
BdsLoadOptionMemMapIsSupported (\r
  IN  EFI_DEVICE_PATH           *DevicePath\r
  );\r
\r
EFI_STATUS\r
BdsLoadOptionPxeList (\r
  IN OUT LIST_ENTRY* BdsLoadOptionList\r
  );\r
\r
EFI_STATUS\r
BdsLoadOptionPxeCreateDevicePath (\r
  IN CHAR16*                    FileName,\r
  OUT EFI_DEVICE_PATH_PROTOCOL  **DevicePathNodes\r
  );\r
\r
EFI_STATUS\r
BdsLoadOptionPxeUpdateDevicePath (\r
  IN EFI_DEVICE_PATH            *OldDevicePath,\r
  IN CHAR16*                    FileName,\r
  OUT EFI_DEVICE_PATH_PROTOCOL  **NewDevicePath\r
  );\r
\r
BOOLEAN\r
BdsLoadOptionPxeIsSupported (\r
  IN  EFI_DEVICE_PATH           *DevicePath\r
  );\r
\r
EFI_STATUS\r
BdsLoadOptionTftpList (\r
  IN OUT LIST_ENTRY* BdsLoadOptionList\r
  );\r
\r
EFI_STATUS\r
BdsLoadOptionTftpCreateDevicePath (\r
  IN CHAR16*                    FileName,\r
  OUT EFI_DEVICE_PATH_PROTOCOL  **DevicePathNodes\r
  );\r
\r
EFI_STATUS\r
BdsLoadOptionTftpUpdateDevicePath (\r
  IN EFI_DEVICE_PATH            *OldDevicePath,\r
  IN CHAR16*                    FileName,\r
  OUT EFI_DEVICE_PATH_PROTOCOL  **NewDevicePath\r
  );\r
\r
BOOLEAN\r
BdsLoadOptionTftpIsSupported (\r
  IN  EFI_DEVICE_PATH           *DevicePath\r
  );\r
\r
BDS_LOAD_OPTION_SUPPORT BdsLoadOptionSupportList[] = {\r
  {\r
    BDS_DEVICE_FILESYSTEM,\r
    BdsLoadOptionFileSystemList,\r
    BdsLoadOptionFileSystemIsSupported,\r
    BdsLoadOptionFileSystemCreateDevicePath,\r
    BdsLoadOptionFileSystemUpdateDevicePath,\r
    TRUE\r
  },\r
  {\r
    BDS_DEVICE_MEMMAP,\r
    BdsLoadOptionMemMapList,\r
    BdsLoadOptionMemMapIsSupported,\r
    BdsLoadOptionMemMapCreateDevicePath,\r
    BdsLoadOptionMemMapUpdateDevicePath,\r
    TRUE\r
  },\r
  {\r
    BDS_DEVICE_PXE,\r
    BdsLoadOptionPxeList,\r
    BdsLoadOptionPxeIsSupported,\r
    BdsLoadOptionPxeCreateDevicePath,\r
    BdsLoadOptionPxeUpdateDevicePath,\r
    FALSE\r
  },\r
  {\r
    BDS_DEVICE_TFTP,\r
    BdsLoadOptionTftpList,\r
    BdsLoadOptionTftpIsSupported,\r
    BdsLoadOptionTftpCreateDevicePath,\r
    BdsLoadOptionTftpUpdateDevicePath,\r
    TRUE\r
  }\r
};\r
\r
EFI_STATUS\r
BootDeviceListSupportedInit (\r
  IN OUT LIST_ENTRY *SupportedDeviceList\r
  )\r
{\r
  UINTN   Index;\r
\r
  // Initialize list of supported devices\r
  InitializeListHead (SupportedDeviceList);\r
\r
  for (Index = 0; Index < BDS_DEVICE_MAX; Index++) {\r
    BdsLoadOptionSupportList[Index].ListDevices (SupportedDeviceList);\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
BootDeviceListSupportedFree (\r
  IN LIST_ENTRY *SupportedDeviceList,\r
  IN BDS_SUPPORTED_DEVICE *Except\r
  )\r
{\r
  LIST_ENTRY  *Entry;\r
  BDS_SUPPORTED_DEVICE* SupportedDevice;\r
\r
  Entry = GetFirstNode (SupportedDeviceList);\r
  while (Entry != SupportedDeviceList) {\r
    SupportedDevice = SUPPORTED_BOOT_DEVICE_FROM_LINK(Entry);\r
    Entry = RemoveEntryList (Entry);\r
    if (SupportedDevice != Except) {\r
      FreePool (SupportedDevice);\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
BootDeviceGetDeviceSupport (\r
  IN  EFI_DEVICE_PATH           *DevicePath,\r
  OUT BDS_LOAD_OPTION_SUPPORT   **DeviceSupport\r
  )\r
{\r
  UINTN Index;\r
\r
  // Find which supported device is the most appropriate\r
  for (Index = 0; Index < BDS_DEVICE_MAX; Index++) {\r
    if (BdsLoadOptionSupportList[Index].IsSupported (DevicePath)) {\r
      *DeviceSupport = &BdsLoadOptionSupportList[Index];\r
      return EFI_SUCCESS;\r
    }\r
  }\r
\r
  return EFI_UNSUPPORTED;\r
}\r
\r
EFI_STATUS\r
BootDeviceGetType (\r
  IN  EFI_DEVICE_PATH* DevicePath,\r
  OUT ARM_BDS_LOADER_TYPE *BootType,\r
  OUT UINT32 *Attributes\r
  )\r
{\r
  EFI_STATUS              Status;\r
  BOOLEAN                 IsEfiApp;\r
  BOOLEAN                 IsBootLoader;\r
  BOOLEAN                 HasFDTSupport;\r
  CHAR16*                 FileName;\r
  EFI_DEVICE_PATH*        PrevDevicePathNode;\r
  EFI_DEVICE_PATH*        DevicePathNode;\r
  EFI_PHYSICAL_ADDRESS    Image;\r
  UINTN                   FileSize;\r
  EFI_IMAGE_DOS_HEADER*   DosHeader;\r
  UINTN                   PeCoffHeaderOffset;\r
  EFI_IMAGE_NT_HEADERS32* NtHeader;\r
\r
  //\r
  // Check if the last node of the device path is a FilePath node\r
  //\r
  PrevDevicePathNode = NULL;\r
  DevicePathNode = DevicePath;\r
  while ((DevicePathNode != NULL) && !IsDevicePathEnd (DevicePathNode)) {\r
    PrevDevicePathNode = DevicePathNode;\r
    DevicePathNode = NextDevicePathNode (DevicePathNode);\r
  }\r
\r
  if ((PrevDevicePathNode != NULL) &&\r
      (PrevDevicePathNode->Type == MEDIA_DEVICE_PATH) &&\r
      (PrevDevicePathNode->SubType == MEDIA_FILEPATH_DP))\r
  {\r
    FileName = ((FILEPATH_DEVICE_PATH*)PrevDevicePathNode)->PathName;\r
  } else {\r
    FileName = NULL;\r
  }\r
\r
  if (FileName == NULL) {\r
    Print(L"Is an EFI Application? ");\r
    Status = GetHIInputBoolean (&IsEfiApp);\r
    if (EFI_ERROR(Status)) {\r
      return EFI_ABORTED;\r
    }\r
  } else if (HasFilePathEfiExtension(FileName)) {\r
    IsEfiApp = TRUE;\r
  } else {\r
    // Check if the file exist\r
    Status = BdsLoadImage (DevicePath, AllocateAnyPages, &Image, &FileSize);\r
    if (!EFI_ERROR (Status)) {\r
\r
      DosHeader = (EFI_IMAGE_DOS_HEADER *)(UINTN) Image;\r
      if (DosHeader->e_magic == EFI_IMAGE_DOS_SIGNATURE) {\r
        //\r
        // DOS image header is present,\r
        // so read the PE header after the DOS image header.\r
        //\r
        PeCoffHeaderOffset = DosHeader->e_lfanew;\r
      } else {\r
        PeCoffHeaderOffset = 0;\r
      }\r
\r
      //\r
      // Check PE/COFF image.\r
      //\r
      NtHeader = (EFI_IMAGE_NT_HEADERS32 *)(UINTN) (Image + PeCoffHeaderOffset);\r
      if (NtHeader->Signature != EFI_IMAGE_NT_SIGNATURE) {\r
        IsEfiApp = FALSE;\r
      } else {\r
        IsEfiApp = TRUE;\r
      }\r
\r
      // Free memory\r
      gBS->FreePages (Image, EFI_SIZE_TO_PAGES(FileSize));\r
    } else {\r
      // If we did not manage to open it then ask for the type\r
      Print(L"Is an EFI Application? ");\r
      Status = GetHIInputBoolean (&IsEfiApp);\r
      if (EFI_ERROR(Status)) {\r
        return EFI_ABORTED;\r
      }\r
    }\r
  }\r
\r
  if (IsEfiApp) {\r
    Print(L"Is your application is an OS loader? ");\r
    Status = GetHIInputBoolean (&IsBootLoader);\r
    if (EFI_ERROR(Status)) {\r
      return EFI_ABORTED;\r
    }\r
    if (!IsBootLoader) {\r
      *Attributes |= LOAD_OPTION_CATEGORY_APP;\r
    }\r
    *BootType = BDS_LOADER_EFI_APPLICATION;\r
  } else {\r
    Print(L"Has FDT support? ");\r
    Status = GetHIInputBoolean (&HasFDTSupport);\r
    if (EFI_ERROR(Status)) {\r
      return EFI_ABORTED;\r
    }\r
    if (HasFDTSupport) {\r
      *BootType = BDS_LOADER_KERNEL_LINUX_FDT;\r
    } else {\r
      *BootType = BDS_LOADER_KERNEL_LINUX_ATAG;\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
BdsLoadOptionFileSystemList (\r
  IN OUT LIST_ENTRY* BdsLoadOptionList\r
  )\r
{\r
  EFI_STATUS                        Status;\r
  UINTN                             HandleCount;\r
  EFI_HANDLE                        *HandleBuffer;\r
  UINTN                             Index;\r
  BDS_SUPPORTED_DEVICE              *SupportedDevice;\r
  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL*  FileProtocol;\r
  EFI_FILE_HANDLE                   Fs;\r
  UINTN                             Size;\r
  EFI_FILE_SYSTEM_INFO*             FsInfo;\r
  EFI_DEVICE_PATH_PROTOCOL*         DevicePathProtocol;\r
\r
  // List all the Simple File System Protocols\r
  Status = gBS->LocateHandleBuffer (ByProtocol, &gEfiSimpleFileSystemProtocolGuid, NULL, &HandleCount, &HandleBuffer);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  for (Index = 0; Index < HandleCount; Index++) {\r
    Status = gBS->HandleProtocol (HandleBuffer[Index], &gEfiDevicePathProtocolGuid, (VOID **)&DevicePathProtocol);\r
    if (!EFI_ERROR(Status)) {\r
      // Allocate BDS Supported Device structure\r
      SupportedDevice = (BDS_SUPPORTED_DEVICE*)AllocatePool (sizeof(BDS_SUPPORTED_DEVICE));\r
\r
      FileProtocol = NULL;\r
      Status = gBS->HandleProtocol (HandleBuffer[Index], &gEfiSimpleFileSystemProtocolGuid, (VOID **)&FileProtocol);\r
      ASSERT_EFI_ERROR(Status);\r
\r
      FileProtocol->OpenVolume (FileProtocol, &Fs);\r
\r
      // Generate a Description from the file system\r
      Size = 0;\r
      FsInfo = NULL;\r
      Status = Fs->GetInfo (Fs, &gEfiFileSystemInfoGuid, &Size, FsInfo);\r
      if (Status == EFI_BUFFER_TOO_SMALL) {\r
        FsInfo = AllocatePool (Size);\r
        Status = Fs->GetInfo (Fs, &gEfiFileSystemInfoGuid, &Size, FsInfo);\r
      }\r
      UnicodeSPrint (SupportedDevice->Description,BOOT_DEVICE_DESCRIPTION_MAX,L"%s (%d MB)",FsInfo->VolumeLabel,(UINT32)(FsInfo->VolumeSize / (1024 * 1024)));\r
      FreePool(FsInfo);\r
      Fs->Close (Fs);\r
\r
      SupportedDevice->DevicePathProtocol = DevicePathProtocol;\r
      SupportedDevice->Support = &BdsLoadOptionSupportList[BDS_DEVICE_FILESYSTEM];\r
\r
      InsertTailList (BdsLoadOptionList,&SupportedDevice->Link);\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
BdsLoadOptionFileSystemCreateDevicePath (\r
  IN CHAR16*                    FileName,\r
  OUT EFI_DEVICE_PATH_PROTOCOL  **DevicePathNodes\r
  )\r
{\r
  EFI_STATUS  Status;\r
  FILEPATH_DEVICE_PATH* FilePathDevicePath;\r
  CHAR16      BootFilePath[BOOT_DEVICE_FILEPATH_MAX];\r
  UINTN       BootFilePathSize;\r
\r
  Print(L"File path of the %s: ", FileName);\r
  Status = GetHIInputStr (BootFilePath, BOOT_DEVICE_FILEPATH_MAX);\r
  if (EFI_ERROR(Status)) {\r
    return EFI_ABORTED;\r
  }\r
\r
  BootFilePathSize = StrSize (BootFilePath);\r
  if (BootFilePathSize == 2) {\r
    *DevicePathNodes = NULL;\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  // Create the FilePath Device Path node\r
  FilePathDevicePath = (FILEPATH_DEVICE_PATH*)AllocatePool(SIZE_OF_FILEPATH_DEVICE_PATH + BootFilePathSize + END_DEVICE_PATH_LENGTH);\r
  FilePathDevicePath->Header.Type = MEDIA_DEVICE_PATH;\r
  FilePathDevicePath->Header.SubType = MEDIA_FILEPATH_DP;\r
  SetDevicePathNodeLength (FilePathDevicePath, SIZE_OF_FILEPATH_DEVICE_PATH + BootFilePathSize);\r
  CopyMem (FilePathDevicePath->PathName, BootFilePath, BootFilePathSize);\r
  SetDevicePathEndNode ((VOID*)((UINTN)FilePathDevicePath + SIZE_OF_FILEPATH_DEVICE_PATH + BootFilePathSize));\r
  *DevicePathNodes = (EFI_DEVICE_PATH_PROTOCOL*)FilePathDevicePath;\r
\r
  return Status;\r
}\r
\r
EFI_STATUS\r
BdsLoadOptionFileSystemUpdateDevicePath (\r
  IN EFI_DEVICE_PATH            *OldDevicePath,\r
  IN CHAR16*                    FileName,\r
  OUT EFI_DEVICE_PATH_PROTOCOL  **NewDevicePath\r
  )\r
{\r
  EFI_STATUS  Status;\r
  CHAR16      BootFilePath[BOOT_DEVICE_FILEPATH_MAX];\r
  UINTN       BootFilePathSize;\r
  FILEPATH_DEVICE_PATH* EndingDevicePath;\r
  FILEPATH_DEVICE_PATH* FilePathDevicePath;\r
  EFI_DEVICE_PATH*  DevicePath;\r
\r
  DevicePath = DuplicateDevicePath (OldDevicePath);\r
\r
  EndingDevicePath = (FILEPATH_DEVICE_PATH*)GetLastDevicePathNode (DevicePath);\r
 \r
  Print(L"File path of the %s: ", FileName);\r
  StrnCpy (BootFilePath, EndingDevicePath->PathName, BOOT_DEVICE_FILEPATH_MAX);\r
  Status = EditHIInputStr (BootFilePath, BOOT_DEVICE_FILEPATH_MAX);\r
  if (EFI_ERROR(Status)) {\r
    return Status;\r
  }\r
\r
  BootFilePathSize = StrSize(BootFilePath);\r
  if (BootFilePathSize == 2) {\r
    *NewDevicePath = NULL;\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  // Create the FilePath Device Path node\r
  FilePathDevicePath = (FILEPATH_DEVICE_PATH*)AllocatePool(SIZE_OF_FILEPATH_DEVICE_PATH + BootFilePathSize);\r
  FilePathDevicePath->Header.Type = MEDIA_DEVICE_PATH;\r
  FilePathDevicePath->Header.SubType = MEDIA_FILEPATH_DP;\r
  SetDevicePathNodeLength (FilePathDevicePath, SIZE_OF_FILEPATH_DEVICE_PATH + BootFilePathSize);\r
  CopyMem (FilePathDevicePath->PathName, BootFilePath, BootFilePathSize);\r
\r
  // Generate the new Device Path by replacing the last node by the updated node\r
  SetDevicePathEndNode (EndingDevicePath);\r
  *NewDevicePath = AppendDevicePathNode (DevicePath, (CONST EFI_DEVICE_PATH_PROTOCOL *)FilePathDevicePath);\r
  FreePool(DevicePath);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
BOOLEAN\r
BdsLoadOptionFileSystemIsSupported (\r
  IN  EFI_DEVICE_PATH           *DevicePath\r
  )\r
{\r
  EFI_DEVICE_PATH*  DevicePathNode;\r
\r
  DevicePathNode = GetLastDevicePathNode (DevicePath);\r
\r
  return IS_DEVICE_PATH_NODE(DevicePathNode,MEDIA_DEVICE_PATH,MEDIA_FILEPATH_DP);\r
}\r
\r
STATIC\r
BOOLEAN\r
IsParentDevicePath (\r
  IN EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath,\r
  IN EFI_DEVICE_PATH_PROTOCOL *ChildDevicePath\r
  )\r
{\r
  UINTN ParentSize;\r
  UINTN ChildSize;\r
\r
  ParentSize = GetDevicePathSize (ParentDevicePath);\r
  ChildSize = GetDevicePathSize (ChildDevicePath);\r
\r
  if (ParentSize > ChildSize) {\r
    return FALSE;\r
  }\r
\r
  if (CompareMem (ParentDevicePath, ChildDevicePath, ParentSize - END_DEVICE_PATH_LENGTH) != 0) {\r
    return FALSE;\r
  }\r
\r
  return TRUE;\r
}\r
\r
EFI_STATUS\r
BdsLoadOptionMemMapList (\r
  IN OUT LIST_ENTRY* BdsLoadOptionList\r
  )\r
{\r
  EFI_STATUS                        Status;\r
  UINTN                             HandleCount;\r
  EFI_HANDLE                        *HandleBuffer;\r
  UINTN                             DevicePathHandleCount;\r
  EFI_HANDLE                        *DevicePathHandleBuffer;\r
  BOOLEAN                           IsParent;\r
  UINTN                             Index;\r
  UINTN                             Index2;\r
  BDS_SUPPORTED_DEVICE              *SupportedDevice;\r
  EFI_DEVICE_PATH_PROTOCOL*         DevicePathProtocol;\r
  EFI_DEVICE_PATH*                  DevicePath;\r
\r
  // List all the BlockIo Protocols\r
  Status = gBS->LocateHandleBuffer (ByProtocol, &gEfiBlockIoProtocolGuid, NULL, &HandleCount, &HandleBuffer);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  for (Index = 0; Index < HandleCount; Index++) {\r
    // We only select the handle WITH a Device Path AND not part of Media (to avoid duplication with HardDisk, CDROM, etc)\r
    Status = gBS->HandleProtocol (HandleBuffer[Index], &gEfiDevicePathProtocolGuid, (VOID **)&DevicePathProtocol);\r
    if (!EFI_ERROR(Status)) {\r
      // BlockIo is not part of Media Device Path\r
      DevicePath = DevicePathProtocol;\r
      while (!IsDevicePathEndType (DevicePath) && (DevicePathType (DevicePath) != MEDIA_DEVICE_PATH)) {\r
        DevicePath = NextDevicePathNode (DevicePath);\r
      }\r
      if (DevicePathType (DevicePath) == MEDIA_DEVICE_PATH) {\r
        continue;\r
      }\r
\r
      // Open all the handle supporting the DevicePath protocol and verify this handle has not got any child\r
      Status = gBS->LocateHandleBuffer (ByProtocol, &gEfiDevicePathProtocolGuid, NULL, &DevicePathHandleCount, &DevicePathHandleBuffer);\r
      ASSERT_EFI_ERROR (Status);\r
      IsParent = FALSE;\r
      for (Index2 = 0; (Index2 < DevicePathHandleCount) && !IsParent; Index2++) {\r
        if (HandleBuffer[Index] != DevicePathHandleBuffer[Index2]) {\r
          gBS->HandleProtocol (DevicePathHandleBuffer[Index2], &gEfiDevicePathProtocolGuid, (VOID **)&DevicePath);\r
          if (IsParentDevicePath (DevicePathProtocol, DevicePath)) {\r
            IsParent = TRUE;\r
          }\r
        }\r
      }\r
      if (IsParent) {\r
        continue;\r
      }\r
\r
      // Allocate BDS Supported Device structure\r
      SupportedDevice = (BDS_SUPPORTED_DEVICE*)AllocatePool(sizeof(BDS_SUPPORTED_DEVICE));\r
\r
      Status = GenerateDeviceDescriptionName (HandleBuffer[Index], SupportedDevice->Description);\r
      ASSERT_EFI_ERROR (Status);\r
\r
      SupportedDevice->DevicePathProtocol = DevicePathProtocol;\r
      SupportedDevice->Support = &BdsLoadOptionSupportList[BDS_DEVICE_MEMMAP];\r
\r
      InsertTailList (BdsLoadOptionList,&SupportedDevice->Link);\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
BdsLoadOptionMemMapCreateDevicePath (\r
  IN CHAR16*                    FileName,\r
  OUT EFI_DEVICE_PATH_PROTOCOL  **DevicePathNodes\r
  )\r
{\r
  EFI_STATUS              Status;\r
  MEMMAP_DEVICE_PATH      *MemMapDevicePath;\r
  CHAR16                  StrStartingAddress[BOOT_DEVICE_ADDRESS_MAX];\r
  CHAR16                  StrEndingAddress[BOOT_DEVICE_ADDRESS_MAX];\r
\r
  Print(L"Starting Address of the %s: ", FileName);\r
  Status = GetHIInputStr (StrStartingAddress, BOOT_DEVICE_ADDRESS_MAX);\r
  if (EFI_ERROR(Status)) {\r
    return EFI_ABORTED;\r
  }\r
\r
  Print(L"Ending Address of the %s: ", FileName);\r
  Status = GetHIInputStr (StrEndingAddress, BOOT_DEVICE_ADDRESS_MAX);\r
  if (EFI_ERROR(Status)) {\r
    return EFI_ABORTED;\r
  }\r
\r
  // Create the MemMap Device Path Node\r
  MemMapDevicePath = (MEMMAP_DEVICE_PATH*)AllocatePool (sizeof(MEMMAP_DEVICE_PATH) + END_DEVICE_PATH_LENGTH);\r
  MemMapDevicePath->Header.Type = HARDWARE_DEVICE_PATH;\r
  MemMapDevicePath->Header.SubType = HW_MEMMAP_DP;\r
  SetDevicePathNodeLength (MemMapDevicePath, sizeof(MEMMAP_DEVICE_PATH));\r
  MemMapDevicePath->MemoryType = EfiBootServicesData;\r
  MemMapDevicePath->StartingAddress = StrHexToUint64 (StrStartingAddress);\r
  MemMapDevicePath->EndingAddress = StrHexToUint64 (StrEndingAddress);\r
\r
  // Set a Device Path End Node after the Memory Map Device Path Node\r
  SetDevicePathEndNode (MemMapDevicePath + 1);\r
  *DevicePathNodes = (EFI_DEVICE_PATH_PROTOCOL*)MemMapDevicePath;\r
\r
  return Status;\r
}\r
\r
EFI_STATUS\r
BdsLoadOptionMemMapUpdateDevicePath (\r
  IN EFI_DEVICE_PATH            *OldDevicePath,\r
  IN CHAR16*                    FileName,\r
  OUT EFI_DEVICE_PATH_PROTOCOL  **NewDevicePath\r
  )\r
{\r
  EFI_STATUS          Status;\r
  CHAR16              StrStartingAddress[BOOT_DEVICE_ADDRESS_MAX];\r
  CHAR16              StrEndingAddress[BOOT_DEVICE_ADDRESS_MAX];\r
  MEMMAP_DEVICE_PATH* EndingDevicePath;\r
  EFI_DEVICE_PATH*    DevicePath;\r
\r
  DevicePath = DuplicateDevicePath (OldDevicePath);\r
  EndingDevicePath = (MEMMAP_DEVICE_PATH*)GetLastDevicePathNode (DevicePath);\r
\r
  Print(L"Starting Address of the %s: ", FileName);\r
  UnicodeSPrint (StrStartingAddress, BOOT_DEVICE_ADDRESS_MAX, L"0x%X", (UINTN)EndingDevicePath->StartingAddress);\r
  Status = EditHIInputStr (StrStartingAddress, BOOT_DEVICE_ADDRESS_MAX);\r
  if (EFI_ERROR(Status)) {\r
    return EFI_ABORTED;\r
  }\r
\r
  Print(L"Ending Address of the %s: ", FileName);\r
  UnicodeSPrint (StrEndingAddress, BOOT_DEVICE_ADDRESS_MAX, L"0x%X", (UINTN)EndingDevicePath->EndingAddress);\r
  Status = EditHIInputStr (StrEndingAddress, BOOT_DEVICE_ADDRESS_MAX);\r
  if (EFI_ERROR(Status)) {\r
    return EFI_ABORTED;\r
  }\r
\r
  EndingDevicePath->StartingAddress = StrHexToUint64 (StrStartingAddress);\r
  EndingDevicePath->EndingAddress = StrHexToUint64 (StrEndingAddress);\r
\r
  if (EFI_ERROR(Status)) {\r
    FreePool(DevicePath);\r
  } else {\r
    *NewDevicePath = DevicePath;\r
  }\r
\r
  return Status;\r
}\r
\r
BOOLEAN\r
BdsLoadOptionMemMapIsSupported (\r
  IN  EFI_DEVICE_PATH           *DevicePath\r
  )\r
{\r
  EFI_DEVICE_PATH*  DevicePathNode;\r
\r
  DevicePathNode = GetLastDevicePathNode (DevicePath);\r
\r
  return IS_DEVICE_PATH_NODE(DevicePathNode,HARDWARE_DEVICE_PATH,HW_MEMMAP_DP);\r
}\r
\r
EFI_STATUS\r
BdsLoadOptionPxeList (\r
  IN OUT LIST_ENTRY* BdsLoadOptionList\r
  )\r
{\r
  EFI_STATUS                        Status;\r
  UINTN                             HandleCount;\r
  EFI_HANDLE                        *HandleBuffer;\r
  UINTN                             Index;\r
  BDS_SUPPORTED_DEVICE              *SupportedDevice;\r
  EFI_DEVICE_PATH_PROTOCOL*         DevicePathProtocol;\r
  EFI_SIMPLE_NETWORK_PROTOCOL*      SimpleNet;\r
  CHAR16                            DeviceDescription[BOOT_DEVICE_DESCRIPTION_MAX];\r
  EFI_MAC_ADDRESS                   *Mac;\r
\r
  // List all the PXE Protocols\r
  Status = gBS->LocateHandleBuffer (ByProtocol, &gEfiPxeBaseCodeProtocolGuid, NULL, &HandleCount, &HandleBuffer);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  for (Index = 0; Index < HandleCount; Index++) {\r
    // We only select the handle WITH a Device Path AND the PXE Protocol\r
    Status = gBS->HandleProtocol (HandleBuffer[Index], &gEfiDevicePathProtocolGuid, (VOID **)&DevicePathProtocol);\r
    if (!EFI_ERROR(Status)) {\r
      // Allocate BDS Supported Device structure\r
      SupportedDevice = (BDS_SUPPORTED_DEVICE*)AllocatePool(sizeof(BDS_SUPPORTED_DEVICE));\r
\r
      Status = gBS->LocateProtocol (&gEfiSimpleNetworkProtocolGuid, NULL, (VOID **)&SimpleNet);\r
      if (!EFI_ERROR(Status)) {\r
        Mac = &SimpleNet->Mode->CurrentAddress;\r
        UnicodeSPrint (DeviceDescription,BOOT_DEVICE_DESCRIPTION_MAX,L"MAC Address: %02x:%02x:%02x:%02x:%02x:%02x", Mac->Addr[0],  Mac->Addr[1],  Mac->Addr[2],  Mac->Addr[3],  Mac->Addr[4],  Mac->Addr[5]);\r
      } else {\r
        Status = GenerateDeviceDescriptionName (HandleBuffer[Index], DeviceDescription);\r
        ASSERT_EFI_ERROR (Status);\r
      }\r
      UnicodeSPrint (SupportedDevice->Description,BOOT_DEVICE_DESCRIPTION_MAX,L"PXE on %s",DeviceDescription);\r
\r
      SupportedDevice->DevicePathProtocol = DevicePathProtocol;\r
      SupportedDevice->Support = &BdsLoadOptionSupportList[BDS_DEVICE_PXE];\r
\r
      InsertTailList (BdsLoadOptionList,&SupportedDevice->Link);\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
BdsLoadOptionPxeCreateDevicePath (\r
  IN CHAR16*                    FileName,\r
  OUT EFI_DEVICE_PATH_PROTOCOL  **DevicePathNodes\r
  )\r
{\r
  *DevicePathNodes = (EFI_DEVICE_PATH_PROTOCOL *) AllocatePool (END_DEVICE_PATH_LENGTH);\r
  SetDevicePathEndNode (*DevicePathNodes);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Update the parameters of a Pxe boot option\r
\r
  @param[in]   OldDevicePath  Current complete device path of the Pxe boot option.\r
                              This has to be a valid complete Pxe boot option path.\r
  @param[in]   FileName       Description of the file the path is asked for\r
  @param[out]  NewDevicePath  Pointer to the new complete device path.\r
\r
  @retval  EFI_SUCCESS            Update completed\r
  @retval  EFI_OUT_OF_RESOURCES   Fail to perform the update due to lack of resource\r
**/\r
EFI_STATUS\r
BdsLoadOptionPxeUpdateDevicePath (\r
  IN EFI_DEVICE_PATH            *OldDevicePath,\r
  IN CHAR16*                    FileName,\r
  OUT EFI_DEVICE_PATH_PROTOCOL  **NewDevicePath\r
  )\r
{\r
  //\r
  // Make a copy of the complete device path that is made of :\r
  // the device path of the device supporting the Pxe base code protocol\r
  // followed by an end node.\r
  //\r
  *NewDevicePath = DuplicateDevicePath (OldDevicePath);\r
  if (*NewDevicePath == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  } else {\r
    return EFI_SUCCESS;\r
  }\r
}\r
\r
BOOLEAN\r
BdsLoadOptionPxeIsSupported (\r
  IN  EFI_DEVICE_PATH           *DevicePath\r
  )\r
{\r
  EFI_STATUS  Status;\r
  EFI_HANDLE Handle;\r
  EFI_DEVICE_PATH_PROTOCOL  *RemainingDevicePath;\r
  EFI_PXE_BASE_CODE_PROTOCOL  *PxeBcProtocol;\r
\r
  Status = BdsConnectDevicePath (DevicePath, &Handle, &RemainingDevicePath);\r
  if (EFI_ERROR(Status)) {\r
    return FALSE;\r
  }\r
\r
  if (!IsDevicePathEnd(RemainingDevicePath)) {\r
    return FALSE;\r
  }\r
\r
  Status = gBS->HandleProtocol (Handle, &gEfiPxeBaseCodeProtocolGuid, (VOID **)&PxeBcProtocol);\r
  if (EFI_ERROR (Status)) {\r
    return FALSE;\r
  } else {\r
    return TRUE;\r
  }\r
}\r
\r
EFI_STATUS\r
BdsLoadOptionTftpList (\r
  IN OUT LIST_ENTRY* BdsLoadOptionList\r
  )\r
{\r
  EFI_STATUS                        Status;\r
  UINTN                             HandleCount;\r
  EFI_HANDLE                        *HandleBuffer;\r
  UINTN                             Index;\r
  BDS_SUPPORTED_DEVICE              *SupportedDevice;\r
  EFI_DEVICE_PATH_PROTOCOL*         DevicePathProtocol;\r
  EFI_SIMPLE_NETWORK_PROTOCOL*      SimpleNet;\r
  CHAR16                            DeviceDescription[BOOT_DEVICE_DESCRIPTION_MAX];\r
  EFI_MAC_ADDRESS                   *Mac;\r
\r
  // List all the PXE Protocols\r
  Status = gBS->LocateHandleBuffer (ByProtocol, &gEfiPxeBaseCodeProtocolGuid, NULL, &HandleCount, &HandleBuffer);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  for (Index = 0; Index < HandleCount; Index++) {\r
    // We only select the handle WITH a Device Path AND the PXE Protocol AND the TFTP Protocol (the TFTP protocol is required to start PXE)\r
    Status = gBS->HandleProtocol (HandleBuffer[Index], &gEfiDevicePathProtocolGuid, (VOID **)&DevicePathProtocol);\r
    if (!EFI_ERROR(Status)) {\r
      // Allocate BDS Supported Device structure\r
      SupportedDevice = (BDS_SUPPORTED_DEVICE*)AllocatePool(sizeof(BDS_SUPPORTED_DEVICE));\r
\r
      Status = gBS->LocateProtocol (&gEfiSimpleNetworkProtocolGuid, NULL, (VOID **)&SimpleNet);\r
      if (!EFI_ERROR(Status)) {\r
        Mac = &SimpleNet->Mode->CurrentAddress;\r
        UnicodeSPrint (DeviceDescription,BOOT_DEVICE_DESCRIPTION_MAX,L"MAC Address: %02x:%02x:%02x:%02x:%02x:%02x", Mac->Addr[0],  Mac->Addr[1],  Mac->Addr[2],  Mac->Addr[3],  Mac->Addr[4],  Mac->Addr[5]);\r
      } else {\r
        Status = GenerateDeviceDescriptionName (HandleBuffer[Index], DeviceDescription);\r
        ASSERT_EFI_ERROR (Status);\r
      }\r
      UnicodeSPrint (SupportedDevice->Description,BOOT_DEVICE_DESCRIPTION_MAX,L"TFTP on %s",DeviceDescription);\r
\r
      SupportedDevice->DevicePathProtocol = DevicePathProtocol;\r
      SupportedDevice->Support = &BdsLoadOptionSupportList[BDS_DEVICE_TFTP];\r
\r
      InsertTailList (BdsLoadOptionList,&SupportedDevice->Link);\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
BdsLoadOptionTftpCreateDevicePath (\r
  IN CHAR16*                    FileName,\r
  OUT EFI_DEVICE_PATH_PROTOCOL  **DevicePathNodes\r
  )\r
{\r
  EFI_STATUS    Status;\r
  BOOLEAN       IsDHCP;\r
  EFI_IP_ADDRESS  LocalIp;\r
  EFI_IP_ADDRESS  RemoteIp;\r
  IPv4_DEVICE_PATH*   IPv4DevicePathNode;\r
  FILEPATH_DEVICE_PATH* FilePathDevicePath;\r
  CHAR16      BootFilePath[BOOT_DEVICE_FILEPATH_MAX];\r
  UINTN       BootFilePathSize;\r
\r
  Print(L"Get the IP address from DHCP: ");\r
  Status = GetHIInputBoolean (&IsDHCP);\r
  if (EFI_ERROR(Status)) {\r
    return EFI_ABORTED;\r
  }\r
\r
  if (!IsDHCP) {\r
    Print(L"Get the static IP address: ");\r
    Status = GetHIInputIP (&LocalIp);\r
    if (EFI_ERROR(Status)) {\r
      return EFI_ABORTED;\r
    }\r
  }\r
\r
  Print(L"Get the TFTP server IP address: ");\r
  Status = GetHIInputIP (&RemoteIp);\r
  if (EFI_ERROR(Status)) {\r
    return EFI_ABORTED;\r
  }\r
\r
  Print(L"File path of the %s : ", FileName);\r
  Status = GetHIInputStr (BootFilePath, BOOT_DEVICE_FILEPATH_MAX);\r
  if (EFI_ERROR(Status)) {\r
    return EFI_ABORTED;\r
  }\r
\r
  BootFilePathSize = StrSize(BootFilePath);\r
  if (BootFilePathSize == 2) {\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  // Allocate the memory for the IPv4 + File Path Device Path Nodes\r
  IPv4DevicePathNode = (IPv4_DEVICE_PATH*)AllocatePool(sizeof(IPv4_DEVICE_PATH) + SIZE_OF_FILEPATH_DEVICE_PATH + BootFilePathSize + END_DEVICE_PATH_LENGTH);\r
\r
  // Create the IPv4 Device Path\r
  IPv4DevicePathNode->Header.Type    = MESSAGING_DEVICE_PATH;\r
  IPv4DevicePathNode->Header.SubType = MSG_IPv4_DP;\r
  SetDevicePathNodeLength (&IPv4DevicePathNode->Header, sizeof(IPv4_DEVICE_PATH));\r
  CopyMem (&IPv4DevicePathNode->LocalIpAddress, &LocalIp.v4, sizeof (EFI_IPv4_ADDRESS));\r
  CopyMem (&IPv4DevicePathNode->RemoteIpAddress, &RemoteIp.v4, sizeof (EFI_IPv4_ADDRESS));\r
  IPv4DevicePathNode->LocalPort  = 0;\r
  IPv4DevicePathNode->RemotePort = 0;\r
  IPv4DevicePathNode->Protocol = EFI_IP_PROTO_TCP;\r
  IPv4DevicePathNode->StaticIpAddress = (IsDHCP != TRUE);\r
\r
  // Create the FilePath Device Path node\r
  FilePathDevicePath = (FILEPATH_DEVICE_PATH*)(IPv4DevicePathNode + 1);\r
  FilePathDevicePath->Header.Type = MEDIA_DEVICE_PATH;\r
  FilePathDevicePath->Header.SubType = MEDIA_FILEPATH_DP;\r
  SetDevicePathNodeLength (FilePathDevicePath, SIZE_OF_FILEPATH_DEVICE_PATH + BootFilePathSize);\r
  CopyMem (FilePathDevicePath->PathName, BootFilePath, BootFilePathSize);\r
\r
  // Set the End Device Path Node\r
  SetDevicePathEndNode ((VOID*)((UINTN)FilePathDevicePath + SIZE_OF_FILEPATH_DEVICE_PATH + BootFilePathSize));\r
  *DevicePathNodes = (EFI_DEVICE_PATH_PROTOCOL*)IPv4DevicePathNode;\r
\r
  return Status;\r
}\r
\r
EFI_STATUS\r
BdsLoadOptionTftpUpdateDevicePath (\r
  IN EFI_DEVICE_PATH            *OldDevicePath,\r
  IN CHAR16*                    FileName,\r
  OUT EFI_DEVICE_PATH_PROTOCOL  **NewDevicePath\r
  )\r
{\r
  ASSERT (0);\r
  return EFI_UNSUPPORTED;\r
}\r
\r
BOOLEAN\r
BdsLoadOptionTftpIsSupported (\r
  IN  EFI_DEVICE_PATH           *DevicePath\r
  )\r
{\r
  EFI_STATUS  Status;\r
  EFI_HANDLE Handle;\r
  EFI_DEVICE_PATH  *RemainingDevicePath;\r
  EFI_DEVICE_PATH  *NextDevicePath;\r
  EFI_PXE_BASE_CODE_PROTOCOL  *PxeBcProtocol;\r
\r
  Status = BdsConnectDevicePath (DevicePath, &Handle, &RemainingDevicePath);\r
  if (EFI_ERROR(Status)) {\r
    return FALSE;\r
  }\r
\r
  // Validate the Remaining Device Path\r
  if (IsDevicePathEnd(RemainingDevicePath)) {\r
    return FALSE;\r
  }\r
  if (!IS_DEVICE_PATH_NODE(RemainingDevicePath,MESSAGING_DEVICE_PATH,MSG_IPv4_DP) &&\r
      !IS_DEVICE_PATH_NODE(RemainingDevicePath,MESSAGING_DEVICE_PATH,MSG_IPv6_DP)) {\r
    return FALSE;\r
  }\r
  NextDevicePath = NextDevicePathNode (RemainingDevicePath);\r
  if (IsDevicePathEnd(NextDevicePath)) {\r
    return FALSE;\r
  }\r
  if (!IS_DEVICE_PATH_NODE(NextDevicePath,MEDIA_DEVICE_PATH,MEDIA_FILEPATH_DP)) {\r
    return FALSE;\r
  }\r
\r
  Status = gBS->HandleProtocol (Handle, &gEfiPxeBaseCodeProtocolGuid, (VOID **)&PxeBcProtocol);\r
  if (EFI_ERROR (Status)) {\r
    return FALSE;\r
  } else {\r
    return TRUE;\r
  }\r
}\r