ShellPkg/UefiHandleParsingLib: Remove some unused Guids

[mirror_edk2.git] / ShellPkg / Library / UefiHandleParsingLib / UefiHandleParsingLib.c

diff --git a/ShellPkg/Library/UefiHandleParsingLib/UefiHandleParsingLib.c b/ShellPkg/Library/UefiHandleParsingLib/UefiHandleParsingLib.c
index b211de7d1d76c2481dce9f53a8c2f151f7e35a3c..f179c410922361e13467a8b9527fbde8cfd6ee82 100644 (file)
--- a/ShellPkg/Library/UefiHandleParsingLib/UefiHandleParsingLib.c
+++ b/ShellPkg/Library/UefiHandleParsingLib/UefiHandleParsingLib.c
@@ -1,26 +1,83 @@
 /** @file\r
   Provides interface to advanced shell functionality for parsing both handle and protocol database.\r
 \r
 /** @file\r
   Provides interface to advanced shell functionality for parsing both handle and protocol database.\r
 \r

-  (C) Copyright 2015 Hewlett Packard Enterprise Development LP<BR>\r
+  Copyright (c) 2010 - 2017, Intel Corporation. All rights reserved.<BR>\r

   (C) Copyright 2013-2015 Hewlett-Packard Development Company, L.P.<BR>\r
   (C) Copyright 2013-2015 Hewlett-Packard Development Company, L.P.<BR>\r

-  Copyright (c) 2010 - 2015, Intel Corporation. All rights reserved.<BR>\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
+  (C) Copyright 2015-2016 Hewlett Packard Enterprise Development LP<BR>\r
+  SPDX-License-Identifier: BSD-2-Clause-Patent\r

 \r
 **/\r
 \r
 #include "UefiHandleParsingLib.h"\r
 #include "IndustryStandard/Acpi10.h"\r
 \r
 **/\r
 \r
 #include "UefiHandleParsingLib.h"\r
 #include "IndustryStandard/Acpi10.h"\r

+#include "IndustryStandard/Pci.h"\r
+#include <PiDxe.h>\r
+#include <Protocol/FirmwareVolume2.h>\r

 \r
 EFI_HANDLE        mHandleParsingHiiHandle = NULL;\r
 HANDLE_INDEX_LIST mHandleList = {{{NULL,NULL},0,0},0};\r
 \r
 EFI_HANDLE        mHandleParsingHiiHandle = NULL;\r
 HANDLE_INDEX_LIST mHandleList = {{{NULL,NULL},0,0},0};\r

-GUID_INFO_BLOCK   *GuidList;\r
-UINTN             GuidListCount;\r
+GUID_INFO_BLOCK   *mGuidList;\r
+UINTN             mGuidListCount;\r
+\r
+/**\r
+  Function to find the file name associated with a LoadedImageProtocol.\r
+\r
+  @param[in] LoadedImage     An instance of LoadedImageProtocol.\r
+\r
+  @retval                    A string representation of the file name associated\r
+                             with LoadedImage, or NULL if no name can be found.\r
+**/\r
+CHAR16*\r
+FindLoadedImageFileName (\r
+  IN EFI_LOADED_IMAGE_PROTOCOL *LoadedImage\r
+  )\r
+{\r
+  EFI_GUID                       *NameGuid;\r
+  EFI_STATUS                     Status;\r
+  EFI_FIRMWARE_VOLUME2_PROTOCOL  *Fv;\r
+  VOID                           *Buffer;\r
+  UINTN                          BufferSize;\r
+  UINT32                         AuthenticationStatus;\r
+\r
+  if ((LoadedImage == NULL) || (LoadedImage->FilePath == NULL)) {\r
+    return NULL;\r
+  }\r
+\r
+  NameGuid = EfiGetNameGuidFromFwVolDevicePathNode((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *)LoadedImage->FilePath);\r
+\r
+  if (NameGuid == NULL) {\r
+    return NULL;\r
+  }\r
+\r
+  //\r
+  // Get the FirmwareVolume2Protocol of the device handle that this image was loaded from.\r
+  //\r
+  Status = gBS->HandleProtocol (LoadedImage->DeviceHandle, &gEfiFirmwareVolume2ProtocolGuid, (VOID**) &Fv);\r
+\r
+  //\r
+  // FirmwareVolume2Protocol is PI, and is not required to be available.\r
+  //\r
+  if (EFI_ERROR (Status)) {\r
+    return NULL;\r
+  }\r
+\r
+  //\r
+  // Read the user interface section of the image.\r
+  //\r
+  Buffer = NULL;\r
+  Status = Fv->ReadSection(Fv, NameGuid, EFI_SECTION_USER_INTERFACE, 0, &Buffer, &BufferSize, &AuthenticationStatus);\r
+\r
+  if (EFI_ERROR (Status)) {\r
+    return NULL;\r
+  }\r
+\r
+  //\r
+  // ReadSection returns just the section data, without any section header. For\r
+  // a user interface section, the only data is the file name.\r
+  //\r
+  return Buffer;\r
+}\r
+\r

 /**\r
   Function to translate the EFI_MEMORY_TYPE into a string.\r
 \r
 /**\r
   Function to translate the EFI_MEMORY_TYPE into a string.\r
 \r


@@ -29,7 +86,6 @@ UINTN             GuidListCount;
   @retval               A string representation of the type allocated from BS Pool.\r
 **/\r
 CHAR16*\r
   @retval               A string representation of the type allocated from BS Pool.\r
 **/\r
 CHAR16*\r

-EFIAPI\r

 ConvertMemoryType (\r
   IN CONST EFI_MEMORY_TYPE Memory\r
   )\r
 ConvertMemoryType (\r
   IN CONST EFI_MEMORY_TYPE Memory\r
   )\r


@@ -66,7 +122,6 @@ ConvertMemoryType (
   @retval               A string representation of the type allocated from BS Pool.\r
 **/\r
 CHAR16*\r
   @retval               A string representation of the type allocated from BS Pool.\r
 **/\r
 CHAR16*\r

-EFIAPI\r

 ConvertPixelFormat (\r
   IN CONST EFI_GRAPHICS_PIXEL_FORMAT Fmt\r
   )\r
 ConvertPixelFormat (\r
   IN CONST EFI_GRAPHICS_PIXEL_FORMAT Fmt\r
   )\r


@@ -100,8 +155,8 @@ HandleParsingLibConstructor (
   IN EFI_SYSTEM_TABLE  *SystemTable\r
   )\r
 {\r
   IN EFI_SYSTEM_TABLE  *SystemTable\r
   )\r
 {\r

-  GuidListCount = 0;\r
-  GuidList      = NULL;\r
+  mGuidListCount = 0;\r
+  mGuidList      = NULL;\r

 \r
   //\r
   // Do nothing with mHandleParsingHiiHandle.  Initialize HII as needed.\r
 \r
   //\r
   // Do nothing with mHandleParsingHiiHandle.  Initialize HII as needed.\r


@@ -139,11 +194,11 @@ HandleParsingLibDestructor (
 {\r
   UINTN                 LoopCount;\r
 \r
 {\r
   UINTN                 LoopCount;\r
 \r

-  for (LoopCount = 0; GuidList != NULL && LoopCount < GuidListCount; LoopCount++) {\r
-    SHELL_FREE_NON_NULL(GuidList[LoopCount].GuidId);\r
+  for (LoopCount = 0; mGuidList != NULL && LoopCount < mGuidListCount; LoopCount++) {\r
+    SHELL_FREE_NON_NULL(mGuidList[LoopCount].GuidId);\r

   }\r
 \r
   }\r
 \r

-  SHELL_FREE_NON_NULL(GuidList);\r
+  SHELL_FREE_NON_NULL(mGuidList);\r

   if (mHandleParsingHiiHandle != NULL) {\r
     HiiRemovePackages(mHandleParsingHiiHandle);\r
   }\r
   if (mHandleParsingHiiHandle != NULL) {\r
     HiiRemovePackages(mHandleParsingHiiHandle);\r
   }\r


@@ -171,20 +226,12 @@ LoadedImageProtocolDumpInformation(
   EFI_STATUS                        Status;\r
   CHAR16                            *RetVal;\r
   CHAR16                            *Temp;\r
   EFI_STATUS                        Status;\r
   CHAR16                            *RetVal;\r
   CHAR16                            *Temp;\r

+  CHAR16                            *FileName;\r
+  CHAR8                             *PdbFileName;\r
+  CHAR16                            *FilePath;\r

   CHAR16                            *CodeType;\r
   CHAR16                            *DataType;\r
 \r
   CHAR16                            *CodeType;\r
   CHAR16                            *DataType;\r
 \r

-  if (!Verbose) {\r
-    return (CatSPrint(NULL, L"LoadedImage"));\r
-  }\r
-\r
-  HandleParsingHiiInit();\r
-\r
-  Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_LI_DUMP_MAIN), NULL);\r
-  if (Temp == NULL) {\r
-    return NULL;\r
-  }\r
-\r

   Status = gBS->OpenProtocol (\r
                 TheHandle,\r
                 &gEfiLoadedImageProtocolGuid,\r
   Status = gBS->OpenProtocol (\r
                 TheHandle,\r
                 &gEfiLoadedImageProtocolGuid,\r


@@ -195,21 +242,50 @@ LoadedImageProtocolDumpInformation(
                );\r
 \r
   if (EFI_ERROR (Status)) {\r
                );\r
 \r
   if (EFI_ERROR (Status)) {\r

-    SHELL_FREE_NON_NULL (Temp);\r

     return NULL;\r
   }\r
 \r
     return NULL;\r
   }\r
 \r

+  FileName = FindLoadedImageFileName(LoadedImage);\r
+  FilePath = ConvertDevicePathToText(LoadedImage->FilePath, TRUE, TRUE);\r
+  if (!Verbose) {\r
+    if (FileName == NULL) {\r
+      FileName = FilePath;\r
+    } else {\r
+      SHELL_FREE_NON_NULL(FilePath);\r
+    }\r
+    return FileName;\r
+  }\r
+\r
+  HandleParsingHiiInit();\r
+  RetVal = NULL;\r
+  if (FileName != NULL) {\r
+    Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_LI_DUMP_NAME), NULL);\r
+\r
+    if (Temp != NULL) {\r
+      RetVal = CatSPrint(NULL, Temp, FileName);\r
+    }\r
+\r
+    SHELL_FREE_NON_NULL(Temp);\r
+    SHELL_FREE_NON_NULL(FileName);\r
+  }\r
+\r
+  Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_LI_DUMP_MAIN), NULL);\r
+  if (Temp == NULL) {\r
+    return NULL;\r
+  }\r
+  PdbFileName = PeCoffLoaderGetPdbPointer (LoadedImage->ImageBase);\r

   DataType = ConvertMemoryType(LoadedImage->ImageDataType);\r
   CodeType = ConvertMemoryType(LoadedImage->ImageCodeType);\r
 \r
   RetVal = CatSPrint(\r
   DataType = ConvertMemoryType(LoadedImage->ImageDataType);\r
   CodeType = ConvertMemoryType(LoadedImage->ImageCodeType);\r
 \r
   RetVal = CatSPrint(\r

-             NULL,\r
+             RetVal,\r

              Temp,\r
              LoadedImage->Revision,\r
              LoadedImage->ParentHandle,\r
              LoadedImage->SystemTable,\r
              LoadedImage->DeviceHandle,\r
              Temp,\r
              LoadedImage->Revision,\r
              LoadedImage->ParentHandle,\r
              LoadedImage->SystemTable,\r
              LoadedImage->DeviceHandle,\r

-             LoadedImage->FilePath,\r
+             FilePath,\r
+             PdbFileName,\r

              LoadedImage->LoadOptionsSize,\r
              LoadedImage->LoadOptions,\r
              LoadedImage->ImageBase,\r
              LoadedImage->LoadOptionsSize,\r
              LoadedImage->LoadOptions,\r
              LoadedImage->ImageBase,\r


@@ -221,6 +297,7 @@ LoadedImageProtocolDumpInformation(
 \r
 \r
   SHELL_FREE_NON_NULL(Temp);\r
 \r
 \r
   SHELL_FREE_NON_NULL(Temp);\r

+  SHELL_FREE_NON_NULL(FilePath);\r

   SHELL_FREE_NON_NULL(CodeType);\r
   SHELL_FREE_NON_NULL(DataType);\r
 \r
   SHELL_FREE_NON_NULL(CodeType);\r
   SHELL_FREE_NON_NULL(DataType);\r
 \r


@@ -244,11 +321,15 @@ GraphicsOutputProtocolDumpInformation(
   IN CONST BOOLEAN    Verbose\r
   )\r
 {\r
   IN CONST BOOLEAN    Verbose\r
   )\r
 {\r

-  EFI_GRAPHICS_OUTPUT_PROTOCOL      *GraphicsOutput;\r
-  EFI_STATUS                        Status;\r
-  CHAR16                            *RetVal;\r
-  CHAR16                            *Temp;\r
-  CHAR16                            *Fmt;\r
+  EFI_GRAPHICS_OUTPUT_PROTOCOL          *GraphicsOutput;\r
+  EFI_STATUS                            Status;\r
+  CHAR16                                *RetVal;\r
+  CHAR16                                *Temp;\r
+  CHAR16                                *Fmt;\r
+  CHAR16                                *TempRetVal;\r
+  UINTN                                 GopInfoSize;\r
+  UINT32                                Mode;\r
+  EFI_GRAPHICS_OUTPUT_MODE_INFORMATION  *GopInfo;\r

 \r
   if (!Verbose) {\r
     return (CatSPrint(NULL, L"GraphicsOutput"));\r
 \r
   if (!Verbose) {\r
     return (CatSPrint(NULL, L"GraphicsOutput"));\r


@@ -295,12 +376,189 @@ GraphicsOutputProtocolDumpInformation(
              GraphicsOutput->Mode->Info->PixelFormat!=PixelBitMask?0:GraphicsOutput->Mode->Info->PixelInformation.BlueMask\r
              );\r
 \r
              GraphicsOutput->Mode->Info->PixelFormat!=PixelBitMask?0:GraphicsOutput->Mode->Info->PixelInformation.BlueMask\r
              );\r
 \r

+  SHELL_FREE_NON_NULL (Temp);\r
+\r
+  Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_GOP_RES_LIST_MAIN), NULL);\r
+  if (Temp == NULL) {\r
+    SHELL_FREE_NON_NULL (RetVal);\r
+    goto EXIT;\r
+  }\r
+\r
+  TempRetVal = CatSPrint (RetVal, Temp);\r
+  SHELL_FREE_NON_NULL (RetVal);\r
+  if (TempRetVal == NULL) {\r
+    goto EXIT;\r
+  }\r
+  RetVal = TempRetVal;\r
+  SHELL_FREE_NON_NULL (Temp);\r
+\r
+  Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_GOP_RES_LIST_ENTRY), NULL);\r
+  if (Temp == NULL) {\r
+    SHELL_FREE_NON_NULL (RetVal);\r
+    goto EXIT;\r
+  }\r
+\r
+\r
+  for (Mode = 0; Mode < GraphicsOutput->Mode->MaxMode; Mode++) {\r
+    Status = GraphicsOutput->QueryMode (\r
+                               GraphicsOutput,\r
+                               Mode,\r
+                               &GopInfoSize,\r
+                               &GopInfo\r
+                               );\r
+    if (EFI_ERROR (Status)) {\r
+      continue;\r
+    }\r
+\r
+    TempRetVal = CatSPrint (\r
+                   RetVal,\r
+                   Temp,\r
+                   Mode,\r
+                   GopInfo->HorizontalResolution,\r
+                   GopInfo->VerticalResolution\r
+                   );\r
+\r
+    SHELL_FREE_NON_NULL (GopInfo);\r
+    SHELL_FREE_NON_NULL (RetVal);\r
+    RetVal = TempRetVal;\r
+  }\r
+\r
+\r
+EXIT:\r

   SHELL_FREE_NON_NULL(Temp);\r
   SHELL_FREE_NON_NULL(Fmt);\r
 \r
   return RetVal;\r
 }\r
 \r
   SHELL_FREE_NON_NULL(Temp);\r
   SHELL_FREE_NON_NULL(Fmt);\r
 \r
   return RetVal;\r
 }\r
 \r

+/**\r
+  Function to dump information about EDID Discovered Protocol.\r
+\r
+  This will allocate the return buffer from boot services pool.\r
+\r
+  @param[in] TheHandle      The handle that has LoadedImage installed.\r
+  @param[in] Verbose        TRUE for additional information, FALSE otherwise.\r
+\r
+  @retval A pointer to a string containing the information.\r
+**/\r
+CHAR16*\r
+EFIAPI\r
+EdidDiscoveredProtocolDumpInformation (\r
+  IN CONST EFI_HANDLE TheHandle,\r
+  IN CONST BOOLEAN    Verbose\r
+  )\r
+{\r
+  EFI_EDID_DISCOVERED_PROTOCOL          *EdidDiscovered;\r
+  EFI_STATUS                            Status;\r
+  CHAR16                                *RetVal;\r
+  CHAR16                                *Temp;\r
+  CHAR16                                *TempRetVal;\r
+\r
+  if (!Verbose) {\r
+    return (CatSPrint (NULL, L"EDIDDiscovered"));\r
+  }\r
+\r
+  Status = gBS->OpenProtocol (\r
+                  TheHandle,\r
+                  &gEfiEdidDiscoveredProtocolGuid,\r
+                  (VOID**)&EdidDiscovered,\r
+                  NULL,\r
+                  NULL,\r
+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+                  );\r
+\r
+  if (EFI_ERROR (Status)) {\r
+    return NULL;\r
+  }\r
+\r
+  Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_EDID_DISCOVERED_MAIN), NULL);\r
+  if (Temp == NULL) {\r
+    return NULL;\r
+  }\r
+\r
+  RetVal = CatSPrint (NULL, Temp, EdidDiscovered->SizeOfEdid);\r
+  SHELL_FREE_NON_NULL (Temp);\r
+\r
+  if (EdidDiscovered->SizeOfEdid != 0) {\r
+    Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_EDID_DISCOVERED_DATA), NULL);\r
+    if (Temp == NULL) {\r
+      SHELL_FREE_NON_NULL (RetVal);\r
+      return NULL;\r
+    }\r
+    TempRetVal = CatSPrint (RetVal, Temp);\r
+    SHELL_FREE_NON_NULL (RetVal);\r
+    RetVal = TempRetVal;\r
+\r
+    TempRetVal = CatSDumpHex (RetVal, 4, 0, EdidDiscovered->SizeOfEdid, EdidDiscovered->Edid);\r
+    RetVal = TempRetVal;\r
+  }\r
+  return RetVal;\r
+}\r
+\r
+/**\r
+  Function to dump information about EDID Active Protocol.\r
+\r
+  This will allocate the return buffer from boot services pool.\r
+\r
+  @param[in] TheHandle      The handle that has LoadedImage installed.\r
+  @param[in] Verbose        TRUE for additional information, FALSE otherwise.\r
+\r
+  @retval A pointer to a string containing the information.\r
+**/\r
+CHAR16*\r
+EFIAPI\r
+EdidActiveProtocolDumpInformation (\r
+  IN CONST EFI_HANDLE TheHandle,\r
+  IN CONST BOOLEAN    Verbose\r
+  )\r
+{\r
+  EFI_EDID_ACTIVE_PROTOCOL  *EdidActive;\r
+  EFI_STATUS                Status;\r
+  CHAR16                    *RetVal;\r
+  CHAR16                    *Temp;\r
+  CHAR16                    *TempRetVal;\r
+\r
+  if (!Verbose) {\r
+    return (CatSPrint (NULL, L"EDIDActive"));\r
+  }\r
+\r
+  Status = gBS->OpenProtocol (\r
+                  TheHandle,\r
+                  &gEfiEdidActiveProtocolGuid,\r
+                  (VOID**)&EdidActive,\r
+                  NULL,\r
+                  NULL,\r
+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+                  );\r
+\r
+  if (EFI_ERROR (Status)) {\r
+    return NULL;\r
+  }\r
+\r
+  Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_EDID_ACTIVE_MAIN), NULL);\r
+  if (Temp == NULL) {\r
+    return NULL;\r
+  }\r
+\r
+  RetVal = CatSPrint (NULL, Temp, EdidActive->SizeOfEdid);\r
+  SHELL_FREE_NON_NULL (Temp);\r
+\r
+  if (EdidActive->SizeOfEdid != 0) {\r
+    Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_EDID_ACTIVE_DATA), NULL);\r
+    if (Temp == NULL) {\r
+      SHELL_FREE_NON_NULL (RetVal);\r
+      return NULL;\r
+    }\r
+    TempRetVal = CatSPrint (RetVal, Temp);\r
+    SHELL_FREE_NON_NULL (RetVal);\r
+    RetVal = TempRetVal;\r
+\r
+    TempRetVal = CatSDumpHex (RetVal, 4, 0, EdidActive->SizeOfEdid, EdidActive->Edid);\r
+    RetVal = TempRetVal;\r
+  }\r
+  return RetVal;\r
+}\r
+\r

 /**\r
   Function to dump information about PciRootBridgeIo.\r
 \r
 /**\r
   Function to dump information about PciRootBridgeIo.\r
 \r


@@ -348,7 +606,7 @@ PciRootBridgeIoDumpInformation(
   if (Temp == NULL) {\r
     return NULL;\r
   }\r
   if (Temp == NULL) {\r
     return NULL;\r
   }\r

-  Temp2 = CatSPrint(L"\r\n", Temp, PciRootBridgeIo->ParentHandle);\r
+  Temp2 = CatSPrint(NULL, Temp, PciRootBridgeIo->ParentHandle);\r

   FreePool(Temp);\r
   RetVal = Temp2;\r
   Temp2 = NULL;\r
   FreePool(Temp);\r
   RetVal = Temp2;\r
   Temp2 = NULL;\r


@@ -418,7 +676,7 @@ PciRootBridgeIoDumpInformation(
         break;\r
       }\r
       if (Temp != NULL) {\r
         break;\r
       }\r
       if (Temp != NULL) {\r

-        Temp2 = CatSPrint(RetVal, L"%s", Temp);\r
+        Temp2 = CatSPrint(RetVal, L"\r\n%s", Temp);\r

         FreePool(Temp);\r
         FreePool(RetVal);\r
         RetVal = Temp2;\r
         FreePool(Temp);\r
         FreePool(RetVal);\r
         RetVal = Temp2;\r


@@ -426,7 +684,7 @@ PciRootBridgeIoDumpInformation(
       }\r
 \r
       Temp2 = CatSPrint(RetVal,\r
       }\r
 \r
       Temp2 = CatSPrint(RetVal,\r

-        L"%H%02x    %016lx  %016lx  %02x%N\r\n",\r
+        L"%%H%02x    %016lx  %016lx  %02x%%N",\r

         Configuration->SpecificFlag,\r
         Configuration->AddrRangeMin,\r
         Configuration->AddrRangeMax,\r
         Configuration->SpecificFlag,\r
         Configuration->AddrRangeMin,\r
         Configuration->AddrRangeMax,\r


@@ -546,45 +804,42 @@ DriverEfiVersionProtocolDumpInformation(
   ASSERT_EFI_ERROR(Status);\r
 \r
   RetVal = AllocateZeroPool(VersionStringSize);\r
   ASSERT_EFI_ERROR(Status);\r
 \r
   RetVal = AllocateZeroPool(VersionStringSize);\r

-  ASSERT(RetVal != NULL);\r
-  UnicodeSPrint(RetVal, VersionStringSize, L"0x%08x", DriverEfiVersion->FirmwareVersion);\r
+  if (RetVal != NULL) {\r
+    UnicodeSPrint (RetVal, VersionStringSize, L"0x%08x", DriverEfiVersion->FirmwareVersion);\r
+  }\r

   return (RetVal);\r
 }\r
   return (RetVal);\r
 }\r

-\r

 /**\r
 /**\r

-  Function to dump information about DevicePath protocol.\r
+  Function to convert device path to string.\r

 \r
   This will allocate the return buffer from boot services pool.\r
 \r
 \r
   This will allocate the return buffer from boot services pool.\r
 \r

-  @param[in] TheHandle      The handle that has the protocol installed.\r
+  @param[in] DevPath        Pointer to device path instance.\r

   @param[in] Verbose        TRUE for additional information, FALSE otherwise.\r
   @param[in] Verbose        TRUE for additional information, FALSE otherwise.\r

+  @param[in] Length         Maximum allowed text length of the device path.\r

 \r
 \r

-  @retval A poitner to a string containing the information.\r
+  @retval A pointer to a string containing the information.\r

 **/\r
 CHAR16*\r
 **/\r
 CHAR16*\r

-EFIAPI\r
-DevicePathProtocolDumpInformation(\r
-  IN CONST EFI_HANDLE TheHandle,\r
-  IN CONST BOOLEAN    Verbose\r
+ConvertDevicePathToShortText(\r
+  IN CONST EFI_DEVICE_PATH_PROTOCOL *DevPath,\r
+  IN CONST BOOLEAN                  Verbose,\r
+  IN CONST UINTN                    Length\r

   )\r
 {\r
   )\r
 {\r

-  EFI_DEVICE_PATH_PROTOCOL          *DevPath;\r

   CHAR16                            *Temp;\r
   CHAR16                            *Temp2;\r
   CHAR16                            *Temp;\r
   CHAR16                            *Temp2;\r

-  EFI_STATUS                        Status;\r
-  Temp = NULL;\r
+  UINTN                             Size;\r

 \r
 \r

-  Status = gBS->OpenProtocol(TheHandle, &gEfiDevicePathProtocolGuid, (VOID**)&DevPath, gImageHandle, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);\r
-  if (!EFI_ERROR(Status)) {\r
-    //\r
-    // I cannot decide whether to allow shortcuts here (the second BOOLEAN on the next line)\r
-    //\r
-    Temp = ConvertDevicePathToText(DevPath, TRUE, TRUE);\r
-    gBS->CloseProtocol(TheHandle, &gEfiDevicePathProtocolGuid, gImageHandle, NULL);\r
-  }\r
-  if (!Verbose && Temp != NULL && StrLen(Temp) > 30) {\r
+  //\r
+  // I cannot decide whether to allow shortcuts here (the second BOOLEAN on the next line)\r
+  //\r
+  Temp = ConvertDevicePathToText(DevPath, TRUE, TRUE);\r
+  if (!Verbose && Temp != NULL && StrLen(Temp) > Length) {\r

     Temp2 = NULL;\r
     Temp2 = NULL;\r

-    Temp2 = StrnCatGrow(&Temp2, NULL, Temp+(StrLen(Temp) - 30), 30);\r
+    Size  = 0;\r
+    Temp2 = StrnCatGrow(&Temp2, &Size, L"..", 0);\r
+    Temp2 = StrnCatGrow(&Temp2, &Size, Temp+(StrLen(Temp) - (Length - 2)), 0);\r

     FreePool(Temp);\r
     Temp = Temp2;\r
   }\r
     FreePool(Temp);\r
     Temp = Temp2;\r
   }\r


@@ -592,7 +847,53 @@ DevicePathProtocolDumpInformation(
 }\r
 \r
 /**\r
 }\r
 \r
 /**\r

-  Function to dump information about EfiAdapterInformation Protocol.\r
+  Function to dump protocol information.\r
+\r
+  This will allocate the return buffer from boot services pool.\r
+\r
+  @param[in] TheHandle      The handle that has the protocol installed.\r
+  @param[in] Verbose        TRUE for additional information, FALSE otherwise.\r
+  @param[in] Protocol       The protocol is needed to dump.\r
+\r
+  @retval A pointer to a string containing the information.\r
+**/\r
+STATIC CHAR16*\r
+EFIAPI\r
+DevicePathProtocolDumpInformationEx (\r
+  IN CONST EFI_HANDLE   TheHandle,\r
+  IN CONST BOOLEAN      Verbose,\r
+  IN       EFI_GUID     *Protocol\r
+)\r
+{\r
+  EFI_DEVICE_PATH_PROTOCOL          *DevPath;\r
+  CHAR16                            *DevPathStr;\r
+  CHAR16                            *DevPathStrTemp;\r
+  UINTN                             Size;\r
+  EFI_STATUS                        Status;\r
+  DevPathStr     = NULL;\r
+  DevPathStrTemp = NULL;\r
+  Status = gBS->OpenProtocol(TheHandle, Protocol, (VOID**)&DevPath, gImageHandle, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);\r
+  if (!EFI_ERROR(Status)) {\r
+    DevPathStr = ConvertDevicePathToShortText (DevPath, Verbose, 30);\r
+    if (Verbose) {\r
+      Size = StrSize(DevPathStr) + sizeof(CHAR16) * 2;\r
+      DevPathStrTemp = AllocateZeroPool (Size);\r
+      if (DevPathStrTemp != NULL) {\r
+        StrnCatS (DevPathStrTemp, Size/sizeof(CHAR16), L"  ", 2);\r
+        StrnCatS (DevPathStrTemp, Size/sizeof(CHAR16), DevPathStr, StrLen (DevPathStr));\r
+      }\r
+      FreePool (DevPathStr);\r
+      DevPathStr = DevPathStrTemp;\r
+    }\r
+    gBS->CloseProtocol(TheHandle, Protocol, gImageHandle, NULL);\r
+  }\r
+  return DevPathStr;\r
+}\r
+\r
+/**\r
+  Function to dump information about DevicePath protocol.\r
+\r
+  This will allocate the return buffer from boot services pool.\r

 \r
   @param[in] TheHandle      The handle that has the protocol installed.\r
   @param[in] Verbose        TRUE for additional information, FALSE otherwise.\r
 \r
   @param[in] TheHandle      The handle that has the protocol installed.\r
   @param[in] Verbose        TRUE for additional information, FALSE otherwise.\r


@@ -601,39 +902,442 @@ DevicePathProtocolDumpInformation(
 **/\r
 CHAR16*\r
 EFIAPI\r
 **/\r
 CHAR16*\r
 EFIAPI\r

-AdapterInformationDumpInformation (\r
+DevicePathProtocolDumpInformation(\r

   IN CONST EFI_HANDLE TheHandle,\r
   IN CONST BOOLEAN    Verbose\r
   )\r
 {\r
   IN CONST EFI_HANDLE TheHandle,\r
   IN CONST BOOLEAN    Verbose\r
   )\r
 {\r

-  EFI_STATUS                        Status;\r
-  EFI_ADAPTER_INFORMATION_PROTOCOL  *EfiAdptrInfoProtocol;\r
-  UINTN                             InfoTypesBufferCount;\r
-  UINTN                             GuidIndex;\r
-  EFI_GUID                          *InfoTypesBuffer;\r
-  CHAR16                            *GuidStr;\r
-  CHAR16                            *TempStr;\r
-  CHAR16                            *RetVal;\r
-  CHAR16                            *TempRetVal;\r
-  VOID                              *InformationBlock;\r
-  UINTN                             InformationBlockSize;\r
+  return DevicePathProtocolDumpInformationEx (TheHandle, Verbose, &gEfiDevicePathProtocolGuid);\r
+}\r

 \r
 \r

-  if (!Verbose) {\r
-    return (CatSPrint(NULL, L"AdapterInfo"));\r
-  }\r
+/**\r
+  Function to dump information about LoadedImageDevicePath protocol.\r

 \r
 \r

-  InfoTypesBuffer   = NULL;\r
-  InformationBlock  = NULL;\r
+  This will allocate the return buffer from boot services pool.\r

 \r
 \r

+  @param[in] TheHandle      The handle that has the protocol installed.\r
+  @param[in] Verbose        TRUE for additional information, FALSE otherwise.\r

 \r
 \r

-  Status = gBS->OpenProtocol (\r
-                  (EFI_HANDLE) (TheHandle),\r
-                  &gEfiAdapterInformationProtocolGuid,\r
-                  (VOID **) &EfiAdptrInfoProtocol,\r
-                  NULL,\r
-                  NULL,\r
-                  EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
-                  );\r
+  @retval A pointer to a string containing the information.\r
+**/\r
+CHAR16*\r
+EFIAPI\r
+LoadedImageDevicePathProtocolDumpInformation(\r
+  IN CONST EFI_HANDLE TheHandle,\r
+  IN CONST BOOLEAN    Verbose\r
+  )\r
+{\r
+  return DevicePathProtocolDumpInformationEx (TheHandle, Verbose, &gEfiLoadedImageDevicePathProtocolGuid);\r
+}\r
+\r
+/**\r
+  Function to dump information about BusSpecificDriverOverride protocol.\r
+\r
+  This will allocate the return buffer from boot services pool.\r
+\r
+  @param[in] TheHandle      The handle that has the protocol installed.\r
+  @param[in] Verbose        TRUE for additional information, FALSE otherwise.\r
+\r
+  @retval A pointer to a string containing the information.\r
+**/\r
+CHAR16*\r
+EFIAPI\r
+BusSpecificDriverOverrideProtocolDumpInformation (\r
+  IN CONST EFI_HANDLE TheHandle,\r
+  IN CONST BOOLEAN    Verbose\r
+  )\r
+{\r
+  EFI_STATUS                                Status;\r
+  CHAR16                                    *GetString;\r
+  CHAR16                                    *RetVal;\r
+  CHAR16                                    *TempRetVal;\r
+  EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL *BusSpecificDriverOverride;\r
+  EFI_LOADED_IMAGE_PROTOCOL                 *LoadedImage;\r
+  EFI_HANDLE                                ImageHandle;\r
+  UINTN                                     Size;\r
+\r
+  if (!Verbose) {\r
+    return NULL;\r
+  }\r
+  Size        = 0;\r
+  GetString   = NULL;\r
+  RetVal      = NULL;\r
+  TempRetVal  = NULL;\r
+  ImageHandle = 0;\r
+\r
+  Status = gBS->OpenProtocol (\r
+                  TheHandle,\r
+                  &gEfiBusSpecificDriverOverrideProtocolGuid,\r
+                  (VOID**)&BusSpecificDriverOverride,\r
+                  gImageHandle,\r
+                  NULL,\r
+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+                  );\r
+  if (EFI_ERROR (Status)) {\r
+    return NULL;\r
+  }\r
+  HandleParsingHiiInit ();\r
+  GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_BSDO_DUMP_MAIN), NULL);\r
+  if (GetString == NULL) {\r
+    return NULL;\r
+  }\r
+  do {\r
+    Status = BusSpecificDriverOverride->GetDriver (\r
+                                          BusSpecificDriverOverride,\r
+                                          &ImageHandle\r
+                                          );\r
+    if (!EFI_ERROR (Status)) {\r
+      Status = gBS->HandleProtocol (\r
+                      ImageHandle,\r
+                      &gEfiLoadedImageProtocolGuid,\r
+                      (VOID **) &LoadedImage\r
+                      );\r
+      if(!EFI_ERROR (Status)) {\r
+        TempRetVal = CatSPrint (\r
+                       TempRetVal,\r
+                       GetString,\r
+                       ConvertHandleToHandleIndex (ImageHandle),\r
+                       ConvertDevicePathToText (LoadedImage->FilePath, TRUE, TRUE)\r
+                       );\r
+        StrnCatGrow (&RetVal, &Size, TempRetVal, 0);\r
+        SHELL_FREE_NON_NULL (TempRetVal);\r
+      }\r
+    }\r
+  } while (!EFI_ERROR (Status));\r
+\r
+  SHELL_FREE_NON_NULL (GetString);\r
+  return RetVal;\r
+}\r
+\r
+/**\r
+  Function to dump information about BlockIo protocol.\r
+\r
+  This will allocate the return buffer from boot services pool.\r
+\r
+  @param[in] TheHandle      The handle that has the protocol installed.\r
+  @param[in] Verbose        TRUE for additional information, FALSE otherwise.\r
+\r
+  @retval A pointer to a string containing the information.\r
+**/\r
+CHAR16*\r
+EFIAPI\r
+BlockIoProtocolDumpInformation (\r
+  IN CONST EFI_HANDLE TheHandle,\r
+  IN CONST BOOLEAN    Verbose\r
+  )\r
+{\r
+  EFI_STATUS            Status;\r
+  EFI_BLOCK_IO_PROTOCOL *BlockIo;\r
+  EFI_BLOCK_IO_MEDIA    *BlockMedia;\r
+  CHAR16                *GetString;\r
+  CHAR16                *RetVal;\r
+\r
+  if (!Verbose) {\r
+    return NULL;\r
+  }\r
+  GetString   = NULL;\r
+  RetVal = NULL;\r
+\r
+  Status = gBS->OpenProtocol (\r
+                TheHandle,\r
+                &gEfiBlockIoProtocolGuid,\r
+                (VOID**)&BlockIo,\r
+                gImageHandle,\r
+                NULL,\r
+                EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+                );\r
+  if (EFI_ERROR (Status)) {\r
+    return NULL;\r
+  }\r
+  BlockMedia = BlockIo->Media;\r
+  //\r
+  // Per spec:\r
+  //   The function (ReadBlocks) must return EFI_NO_MEDIA or\r
+  //   EFI_MEDIA_CHANGED even if LBA, BufferSize, or Buffer are invalid so the caller can probe\r
+  //   for changes in media state.\r
+  //\r
+  BlockIo->ReadBlocks (\r
+             BlockIo,\r
+             BlockIo->Media->MediaId,\r
+             0,\r
+             0,\r
+             NULL\r
+             );\r
+\r
+  HandleParsingHiiInit ();\r
+  GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_BLOCKIO_INFO), NULL);\r
+  if (GetString == NULL) {\r
+    return NULL;\r
+  }\r
+  RetVal = CatSPrint (\r
+            RetVal,\r
+            GetString,\r
+            BlockMedia->RemovableMedia ? L"Removable " : L"Fixed ",\r
+            BlockMedia->MediaPresent ? L"" : L"not-present ",\r
+            BlockMedia->MediaId,\r
+            BlockMedia->BlockSize,\r
+            BlockMedia->LastBlock,\r
+            MultU64x32 (BlockMedia->LastBlock + 1, BlockMedia->BlockSize),\r
+            BlockMedia->LogicalPartition ? L"partition" : L"raw",\r
+            BlockMedia->ReadOnly ? L"ro" : L"rw",\r
+            BlockMedia->WriteCaching ? L"cached" : L"!cached"\r
+            );\r
+\r
+  SHELL_FREE_NON_NULL (GetString);\r
+  return RetVal;\r
+}\r
+\r
+/**\r
+  Function to dump information about DebugSupport Protocol.\r
+\r
+  @param[in] TheHandle      The handle that has the protocol installed.\r
+  @param[in] Verbose        TRUE for additional information, FALSE otherwise.\r
+\r
+  @retval A pointer to a string containing the information.\r
+**/\r
+CHAR16*\r
+EFIAPI\r
+DebugSupportProtocolDumpInformation (\r
+  IN CONST EFI_HANDLE TheHandle,\r
+  IN CONST BOOLEAN    Verbose\r
+  )\r
+{\r
+  EFI_STATUS                  Status;\r
+  EFI_DEBUG_SUPPORT_PROTOCOL  *DebugSupport;\r
+  CHAR16                      *GetString;\r
+  CHAR16                      *RetVal;\r
+\r
+  if (!Verbose) {\r
+    return NULL;\r
+  }\r
+  GetString = NULL;\r
+  RetVal = NULL;\r
+  Status = gBS->OpenProtocol (\r
+                TheHandle,\r
+                &gEfiDebugSupportProtocolGuid,\r
+                (VOID**)&DebugSupport,\r
+                gImageHandle,\r
+                NULL,\r
+                EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+                );\r
+  if (EFI_ERROR (Status)) {\r
+    return NULL;\r
+  }\r
+  HandleParsingHiiInit ();\r
+  GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_DEBUGSUPPORT_INFO), NULL);\r
+  if (GetString == NULL) {\r
+    return NULL;\r
+  }\r
+  //\r
+  // Dump Debug support info\r
+  //\r
+  switch (DebugSupport->Isa) {\r
+  case (IsaIa32):\r
+    RetVal = CatSPrint (RetVal, GetString, L"IA-32");\r
+    break;\r
+  case (IsaIpf):\r
+    RetVal = CatSPrint (RetVal, GetString, L"IPF");\r
+    break;\r
+  case (IsaEbc):\r
+    RetVal = CatSPrint (RetVal, GetString, L"EBC");\r
+    break;\r
+  default:\r
+    SHELL_FREE_NON_NULL (GetString);\r
+    GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_DEBUGSUPPORT_UNKNOWN), NULL);\r
+    RetVal = GetString != NULL ? CatSPrint (RetVal, GetString, DebugSupport->Isa) : NULL;\r
+    break;\r
+  }\r
+\r
+  SHELL_FREE_NON_NULL (GetString);\r
+  return RetVal;\r
+}\r
+\r
+/**\r
+  Function to dump information about PciIoProtocol.\r
+\r
+  This will allocate the return buffer from boot services pool.\r
+\r
+  @param[in] TheHandle      The handle that has PciRootBridgeIo installed.\r
+  @param[in] Verbose        TRUE for additional information, FALSE otherwise.\r
+\r
+  @retval A poitner to a string containing the information.\r
+**/\r
+CHAR16*\r
+EFIAPI\r
+PciIoProtocolDumpInformation (\r
+  IN CONST EFI_HANDLE TheHandle,\r
+  IN CONST BOOLEAN    Verbose\r
+  )\r
+{\r
+  EFI_STATUS              Status;\r
+  EFI_PCI_IO_PROTOCOL     *PciIo;\r
+  PCI_TYPE00              Pci;\r
+  UINTN                   Segment;\r
+  UINTN                   Bus;\r
+  UINTN                   Device;\r
+  UINTN                   Function;\r
+  UINTN                   Index;\r
+  CHAR16                  *GetString;\r
+  CHAR16                  *TempRetVal;\r
+  CHAR16                  *RetVal;\r
+\r
+  if (!Verbose) {\r
+    return (NULL);\r
+  }\r
+  RetVal = NULL;\r
+  GetString   = NULL;\r
+  TempRetVal  = NULL;\r
+  Status = gBS->OpenProtocol (\r
+                  TheHandle,\r
+                  &gEfiPciIoProtocolGuid,\r
+                  (VOID**)&PciIo,\r
+                  gImageHandle,\r
+                  NULL,\r
+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+                  );\r
+\r
+  if (EFI_ERROR(Status)) {\r
+    return NULL;\r
+  }\r
+  PciIo->Pci.Read (PciIo, EfiPciIoWidthUint8, 0, sizeof (Pci), &Pci);\r
+  PciIo->GetLocation (PciIo, &Segment, &Bus, &Device, &Function);\r
+  HandleParsingHiiInit ();\r
+  GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIIO_DUMP_MAIN), NULL);\r
+  if (GetString == NULL) {\r
+    return NULL;\r
+  }\r
+  RetVal = CatSPrint (\r
+            NULL,\r
+            GetString,\r
+            Segment,\r
+            Bus,\r
+            Device,\r
+            Function,\r
+            PciIo->RomSize,\r
+            PciIo->RomImage,\r
+            Pci.Hdr.VendorId,\r
+            Pci.Hdr.DeviceId,\r
+            Pci.Hdr.ClassCode[0],\r
+            Pci.Hdr.ClassCode[1],\r
+            Pci.Hdr.ClassCode[2]\r
+            );\r
+  for (Index = 0; Index < sizeof (Pci); Index ++) {\r
+    if ((Index % 0x10) == 0) {\r
+      TempRetVal = CatSPrint (RetVal, L"\r\n       %02x", *((UINT8 *) (&Pci) + Index));\r
+    } else {\r
+      TempRetVal = CatSPrint (RetVal, L"%02x", *((UINT8 *) (&Pci) + Index));\r
+    }\r
+    FreePool (RetVal);\r
+    RetVal = TempRetVal;\r
+    TempRetVal = NULL;\r
+  }\r
+\r
+  FreePool(GetString);\r
+  return RetVal;\r
+}\r
+\r
+/**\r
+  Function to dump information about UsbIoProtocol.\r
+\r
+  This will allocate the return buffer from boot services pool.\r
+\r
+  @param[in] TheHandle      The handle that has PciRootBridgeIo installed.\r
+  @param[in] Verbose        TRUE for additional information, FALSE otherwise.\r
+\r
+  @retval A poitner to a string containing the information.\r
+**/\r
+CHAR16*\r
+EFIAPI\r
+UsbIoProtocolDumpInformation (\r
+  IN CONST EFI_HANDLE TheHandle,\r
+  IN CONST BOOLEAN    Verbose\r
+  )\r
+{\r
+  EFI_STATUS                    Status;\r
+  EFI_USB_IO_PROTOCOL           *UsbIo;\r
+  EFI_USB_INTERFACE_DESCRIPTOR  InterfaceDesc;\r
+  CHAR16                        *GetString;\r
+  CHAR16                        *RetVal;\r
+\r
+  if (!Verbose) {\r
+    return (NULL);\r
+  }\r
+  RetVal = NULL;\r
+  GetString = NULL;\r
+  Status = gBS->OpenProtocol (\r
+                  TheHandle,\r
+                  &gEfiUsbIoProtocolGuid,\r
+                  (VOID**)&UsbIo,\r
+                  gImageHandle,\r
+                  NULL,\r
+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+                  );\r
+\r
+  if (EFI_ERROR(Status)) {\r
+    return NULL;\r
+  }\r
+  UsbIo->UsbGetInterfaceDescriptor (UsbIo, &InterfaceDesc);\r
+  HandleParsingHiiInit ();\r
+  GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_USBIO_DUMP_MAIN), NULL);\r
+  if (GetString == NULL) {\r
+    return NULL;\r
+  }\r
+  RetVal = CatSPrint (\r
+            NULL,\r
+            GetString,\r
+            InterfaceDesc.InterfaceNumber,\r
+            InterfaceDesc.InterfaceClass,\r
+            InterfaceDesc.InterfaceSubClass,\r
+            InterfaceDesc.InterfaceProtocol\r
+            );\r
+\r
+  FreePool (GetString);\r
+  return RetVal;\r
+}\r
+\r
+/**\r
+  Function to dump information about EfiAdapterInformation Protocol.\r
+\r
+  @param[in] TheHandle      The handle that has the protocol installed.\r
+  @param[in] Verbose        TRUE for additional information, FALSE otherwise.\r
+\r
+  @retval A pointer to a string containing the information.\r
+**/\r
+CHAR16*\r
+EFIAPI\r
+AdapterInformationDumpInformation (\r
+  IN CONST EFI_HANDLE TheHandle,\r
+  IN CONST BOOLEAN    Verbose\r
+  )\r
+{\r
+  EFI_STATUS                        Status;\r
+  EFI_ADAPTER_INFORMATION_PROTOCOL  *EfiAdptrInfoProtocol;\r
+  UINTN                             InfoTypesBufferCount;\r
+  UINTN                             GuidIndex;\r
+  EFI_GUID                          *InfoTypesBuffer;\r
+  CHAR16                            *GuidStr;\r
+  CHAR16                            *TempStr;\r
+  CHAR16                            *RetVal;\r
+  CHAR16                            *TempRetVal;\r
+  VOID                              *InformationBlock;\r
+  UINTN                             InformationBlockSize;\r
+\r
+  if (!Verbose) {\r
+    return (CatSPrint(NULL, L"AdapterInfo"));\r
+  }\r
+\r
+  InfoTypesBuffer   = NULL;\r
+  InformationBlock  = NULL;\r
+\r
+\r
+  Status = gBS->OpenProtocol (\r
+                  (EFI_HANDLE) (TheHandle),\r
+                  &gEfiAdapterInformationProtocolGuid,\r
+                  (VOID **) &EfiAdptrInfoProtocol,\r
+                  NULL,\r
+                  NULL,\r
+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+                  );\r

 \r
   if (EFI_ERROR (Status)) {\r
     return NULL;\r
 \r
   if (EFI_ERROR (Status)) {\r
     return NULL;\r


@@ -660,152 +1364,648 @@ AdapterInformationDumpInformation (
     if (TempStr == NULL) {\r
       goto ERROR_EXIT;\r
     }\r
     if (TempStr == NULL) {\r
       goto ERROR_EXIT;\r
     }\r

-    RetVal = CatSPrint (NULL, TempStr);\r
+    RetVal = CatSPrint (NULL, TempStr);\r
+    SHELL_FREE_NON_NULL (TempStr);\r
+\r
+    for (GuidIndex = 0; GuidIndex < InfoTypesBufferCount; GuidIndex++) {\r
+      TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_GUID_NUMBER), NULL);\r
+      if (TempStr == NULL) {\r
+        goto ERROR_EXIT;\r
+      }\r
+      TempRetVal = CatSPrint (RetVal, TempStr, (GuidIndex + 1), &InfoTypesBuffer[GuidIndex]);\r
+      SHELL_FREE_NON_NULL (RetVal);\r
+      RetVal = TempRetVal;\r
+      SHELL_FREE_NON_NULL (TempStr);\r
+\r
+      TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_GUID_STRING), NULL);\r
+      if (TempStr == NULL) {\r
+        goto ERROR_EXIT;\r
+      }\r
+\r
+      if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoMediaStateGuid)) {\r
+        TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoMediaStateGuid");\r
+        SHELL_FREE_NON_NULL (RetVal);\r
+        RetVal = TempRetVal;\r
+      } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoNetworkBootGuid)) {\r
+        TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoNetworkBootGuid");\r
+        SHELL_FREE_NON_NULL (RetVal);\r
+        RetVal = TempRetVal;\r
+      } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoSanMacAddressGuid)) {\r
+        TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoSanMacAddressGuid");\r
+        SHELL_FREE_NON_NULL (RetVal);\r
+        RetVal = TempRetVal;\r
+      } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoUndiIpv6SupportGuid)) {\r
+        TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoUndiIpv6SupportGuid");\r
+        SHELL_FREE_NON_NULL (RetVal);\r
+        RetVal = TempRetVal;\r
+      } else {\r
+\r
+        GuidStr = GetStringNameFromGuid (&InfoTypesBuffer[GuidIndex], NULL);\r
+        if (GuidStr == NULL) {\r
+          TempRetVal = CatSPrint (RetVal, TempStr, L"UnknownInfoType");\r
+          SHELL_FREE_NON_NULL (RetVal);\r
+          RetVal = TempRetVal;\r
+\r
+          SHELL_FREE_NON_NULL (TempStr);\r
+          SHELL_FREE_NON_NULL(GuidStr);\r
+          //\r
+          // So that we never have to pass this UnknownInfoType to the parsing function "GetInformation" service of AIP\r
+          //\r
+          continue;\r
+        } else {\r
+          TempRetVal = CatSPrint (RetVal, TempStr, GuidStr);\r
+          SHELL_FREE_NON_NULL (RetVal);\r
+          RetVal = TempRetVal;\r
+          SHELL_FREE_NON_NULL(GuidStr);\r
+        }\r
+      }\r
+\r
+      SHELL_FREE_NON_NULL (TempStr);\r
+\r
+      Status = EfiAdptrInfoProtocol->GetInformation (\r
+                                       EfiAdptrInfoProtocol,\r
+                                       &InfoTypesBuffer[GuidIndex],\r
+                                       &InformationBlock,\r
+                                       &InformationBlockSize\r
+                                       );\r
+\r
+      if (EFI_ERROR (Status)) {\r
+        TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_GETINFO_FAILED), NULL);\r
+        if (TempStr == NULL) {\r
+          goto ERROR_EXIT;\r
+        }\r
+        TempRetVal = CatSPrint (RetVal, TempStr, Status);\r
+        SHELL_FREE_NON_NULL (RetVal);\r
+        RetVal = TempRetVal;\r
+      } else {\r
+        if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoMediaStateGuid)) {\r
+          TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_MEDIA_STATE), NULL);\r
+          if (TempStr == NULL) {\r
+            goto ERROR_EXIT;\r
+          }\r
+          TempRetVal = CatSPrint (\r
+                         RetVal,\r
+                         TempStr,\r
+                         ((EFI_ADAPTER_INFO_MEDIA_STATE *)InformationBlock)->MediaState,\r
+                         ((EFI_ADAPTER_INFO_MEDIA_STATE *)InformationBlock)->MediaState\r
+                         );\r
+          SHELL_FREE_NON_NULL (RetVal);\r
+          RetVal = TempRetVal;\r
+        } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoNetworkBootGuid)) {\r
+          TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_NETWORK_BOOT_INFO), NULL);\r
+          if (TempStr == NULL) {\r
+            goto ERROR_EXIT;\r
+          }\r
+          TempRetVal = CatSPrint (\r
+                         RetVal,\r
+                         TempStr,\r
+                         ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiIpv4BootCapablity,\r
+                         ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiIpv6BootCapablity,\r
+                         ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->FCoeBootCapablity,\r
+                         ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->OffloadCapability,\r
+                         ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiMpioCapability,\r
+                         ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiIpv4Boot,\r
+                         ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiIpv6Boot,\r
+                         ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->FCoeBoot\r
+                         );\r
+          SHELL_FREE_NON_NULL (RetVal);\r
+          RetVal = TempRetVal;\r
+        } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoSanMacAddressGuid) == TRUE) {\r
+          TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_SAN_MAC_ADDRESS_INFO), NULL);\r
+          if (TempStr == NULL) {\r
+            goto ERROR_EXIT;\r
+          }\r
+          TempRetVal = CatSPrint (\r
+                         RetVal,\r
+                         TempStr,\r
+                         ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[0],\r
+                         ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[1],\r
+                         ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[2],\r
+                         ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[3],\r
+                         ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[4],\r
+                         ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[5]\r
+                         );\r
+          SHELL_FREE_NON_NULL (RetVal);\r
+          RetVal = TempRetVal;\r
+        } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoUndiIpv6SupportGuid) == TRUE) {\r
+          TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_UNDI_IPV6_INFO), NULL);\r
+          if (TempStr == NULL) {\r
+            goto ERROR_EXIT;\r
+          }\r
+\r
+          TempRetVal = CatSPrint (\r
+                         RetVal,\r
+                         TempStr,\r
+                         ((EFI_ADAPTER_INFO_UNDI_IPV6_SUPPORT *)InformationBlock)->Ipv6Support\r
+                         );\r
+          SHELL_FREE_NON_NULL (RetVal);\r
+          RetVal = TempRetVal;\r
+        } else {\r
+          TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_UNKNOWN_INFO_TYPE), NULL);\r
+          if (TempStr == NULL) {\r
+            goto ERROR_EXIT;\r
+          }\r
+          TempRetVal = CatSPrint (RetVal, TempStr, &InfoTypesBuffer[GuidIndex]);\r
+          SHELL_FREE_NON_NULL (RetVal);\r
+          RetVal = TempRetVal;\r
+        }\r
+      }\r
+      SHELL_FREE_NON_NULL (TempStr);\r
+      SHELL_FREE_NON_NULL (InformationBlock);\r
+    }\r
+  }\r
+\r
+  SHELL_FREE_NON_NULL (InfoTypesBuffer);\r
+  return RetVal;\r
+\r
+ERROR_EXIT:\r
+  SHELL_FREE_NON_NULL (RetVal);\r
+  SHELL_FREE_NON_NULL (InfoTypesBuffer);\r
+  SHELL_FREE_NON_NULL (InformationBlock);\r
+  return NULL;\r
+}\r
+\r
+/**\r
+  Function to dump information about EFI_FIRMWARE_MANAGEMENT_PROTOCOL Protocol.\r
+\r
+  @param[in] TheHandle      The handle that has the protocol installed.\r
+  @param[in] Verbose        TRUE for additional information, FALSE otherwise.\r
+\r
+  @retval A pointer to a string containing the information.\r
+**/\r
+CHAR16*\r
+EFIAPI\r
+FirmwareManagementDumpInformation (\r
+  IN CONST EFI_HANDLE TheHandle,\r
+  IN CONST BOOLEAN    Verbose\r
+  )\r
+{\r
+  EFI_STATUS                          Status;\r
+  EFI_FIRMWARE_MANAGEMENT_PROTOCOL    *EfiFwMgmtProtocol;\r
+  EFI_FIRMWARE_IMAGE_DESCRIPTOR       *ImageInfo;\r
+  EFI_FIRMWARE_IMAGE_DESCRIPTOR_V1    *ImageInfoV1;\r
+  EFI_FIRMWARE_IMAGE_DESCRIPTOR_V2    *ImageInfoV2;\r
+  UINT64                              AttributeSetting;\r
+  UINTN                               ImageInfoSize;\r
+  UINTN                               DescriptorSize;\r
+  UINT32                              DescriptorVersion;\r
+  UINT32                              PackageVersion;\r
+  UINT8                               DescriptorCount;\r
+  UINT8                               Index;\r
+  UINT8                               Index1;\r
+  UINT8                               ImageCount;\r
+  CHAR16                              *PackageVersionName;\r
+  CHAR16                              *TempStr;\r
+  CHAR16                              *RetVal;\r
+  CHAR16                              *TempRetVal;\r
+  CHAR16                              *AttributeSettingStr;\r
+  BOOLEAN                             Found;\r
+  BOOLEAN                             AttributeSupported;\r
+\r
+  //\r
+  // Initialize local variables\r
+  //\r
+  ImageCount             = 0;\r
+  ImageInfoSize          = 1;\r
+  AttributeSetting       = 0;\r
+  Found                  = FALSE;\r
+  AttributeSupported     = FALSE;\r
+  ImageInfo              = NULL;\r
+  ImageInfoV1            = NULL;\r
+  ImageInfoV2            = NULL;\r
+  PackageVersionName     = NULL;\r
+  RetVal                 = NULL;\r
+  TempRetVal             = NULL;\r
+  TempStr                = NULL;\r
+  AttributeSettingStr    = NULL;\r
+\r
+  if (!Verbose) {\r
+    return (CatSPrint(NULL, L"FirmwareManagement"));\r
+  }\r
+\r
+  Status = gBS->OpenProtocol (\r
+                  (EFI_HANDLE) (TheHandle),\r
+                  &gEfiFirmwareManagementProtocolGuid,\r
+                  (VOID **) &EfiFwMgmtProtocol,\r
+                  NULL,\r
+                  NULL,\r
+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+                  );\r
+\r
+  if (EFI_ERROR (Status)) {\r
+    return NULL;\r
+  }\r
+\r
+  Status = EfiFwMgmtProtocol->GetImageInfo (\r
+                                EfiFwMgmtProtocol,\r
+                                &ImageInfoSize,\r
+                                ImageInfo,\r
+                                &DescriptorVersion,\r
+                                &DescriptorCount,\r
+                                &DescriptorSize,\r
+                                &PackageVersion,\r
+                                &PackageVersionName\r
+                                );\r
+\r
+  if (Status == EFI_BUFFER_TOO_SMALL) {\r
+    ImageInfo = AllocateZeroPool (ImageInfoSize);\r
+\r
+    if (ImageInfo == NULL) {\r
+      Status = EFI_OUT_OF_RESOURCES;\r
+    } else {\r
+      Status = EfiFwMgmtProtocol->GetImageInfo (\r
+                                    EfiFwMgmtProtocol,\r
+                                    &ImageInfoSize,\r
+                                    ImageInfo,\r
+                                    &DescriptorVersion,\r
+                                    &DescriptorCount,\r
+                                    &DescriptorSize,\r
+                                    &PackageVersion,\r
+                                    &PackageVersionName\r
+                                    );\r
+    }\r
+  }\r
+\r
+  if (EFI_ERROR (Status)) {\r
+    goto ERROR_EXIT;\r
+  }\r
+\r
+  //\r
+  // Decode Image Descriptor data only if its version is supported\r
+  //\r
+  if (DescriptorVersion <= EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION) {\r
+\r
+    if (ImageInfo == NULL) {\r
+      goto ERROR_EXIT;\r
+    }\r
+\r
+    ImageInfoV1 = (EFI_FIRMWARE_IMAGE_DESCRIPTOR_V1 *)ImageInfo;\r
+    ImageInfoV2 = (EFI_FIRMWARE_IMAGE_DESCRIPTOR_V2 *)ImageInfo;\r
+\r
+    //\r
+    // Set ImageInfoSize in return buffer\r
+    //\r
+    TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_IMAGE_INFO_SIZE), NULL);\r
+    if (TempStr == NULL) {\r
+      goto ERROR_EXIT;\r
+    }\r
+    RetVal = CatSPrint (NULL, TempStr, ImageInfoSize);\r
+    SHELL_FREE_NON_NULL (TempStr);\r
+\r
+    //\r
+    // Set DescriptorVersion in return buffer\r
+    //\r
+    TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_DESCRIPTOR_VERSION), NULL);\r
+    if (TempStr == NULL) {\r
+      goto ERROR_EXIT;\r
+    }\r
+    TempRetVal = CatSPrint (RetVal, TempStr, DescriptorVersion);\r
+    SHELL_FREE_NON_NULL (RetVal);\r
+    RetVal = TempRetVal;\r
+    SHELL_FREE_NON_NULL (TempStr);\r
+\r
+    //\r
+    // Set DescriptorCount in return buffer\r
+    //\r
+    TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_DESCRIPTOR_COUNT), NULL);\r
+    if (TempStr == NULL) {\r
+      goto ERROR_EXIT;\r
+    }\r
+    TempRetVal = CatSPrint (RetVal, TempStr, DescriptorCount);\r
+    SHELL_FREE_NON_NULL (RetVal);\r
+    RetVal = TempRetVal;\r
+    SHELL_FREE_NON_NULL (TempStr);\r
+\r
+\r
+    //\r
+    // Set DescriptorSize in return buffer\r
+    //\r
+    TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_DESCRIPTOR_SIZE), NULL);\r
+    if (TempStr == NULL) {\r
+      goto ERROR_EXIT;\r
+    }\r
+    TempRetVal = CatSPrint (RetVal, TempStr, DescriptorSize);\r
+    SHELL_FREE_NON_NULL (RetVal);\r
+    RetVal = TempRetVal;\r
+    SHELL_FREE_NON_NULL (TempStr);\r
+\r
+    //\r
+    // Set PackageVersion in return buffer\r
+    //\r
+    TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_PACKAGE_VERSION), NULL);\r
+    if (TempStr == NULL) {\r
+      goto ERROR_EXIT;\r
+    }\r
+    TempRetVal = CatSPrint (RetVal, TempStr, PackageVersion);\r
+    SHELL_FREE_NON_NULL (RetVal);\r
+    RetVal = TempRetVal;\r
+    SHELL_FREE_NON_NULL (TempStr);\r
+\r
+    //\r
+    // Set PackageVersionName in return buffer\r
+    //\r
+    TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_PACKAGE_VERSION_NAME), NULL);\r
+    if (TempStr == NULL) {\r
+      goto ERROR_EXIT;\r
+    }\r
+    TempRetVal = CatSPrint (RetVal, TempStr, PackageVersionName);\r
+    SHELL_FREE_NON_NULL (RetVal);\r
+    RetVal = TempRetVal;\r

     SHELL_FREE_NON_NULL (TempStr);\r
 \r
     SHELL_FREE_NON_NULL (TempStr);\r
 \r

-    for (GuidIndex = 0; GuidIndex < InfoTypesBufferCount; GuidIndex++) {\r
-      TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_GUID_NUMBER), NULL);\r
-      if (TempStr == NULL) {\r
-        goto ERROR_EXIT;\r
+    for (Index = 0; Index < DescriptorCount; Index++) {\r
+      //\r
+      // First check if Attribute is supported\r
+      // and generate a string for AttributeSetting field\r
+      //\r
+      SHELL_FREE_NON_NULL (AttributeSettingStr);\r
+      AttributeSupported = FALSE;\r
+      AttributeSetting   = 0;\r
+      if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1) {\r
+        if (ImageInfoV1[Index].AttributesSupported != 0x0) {\r
+          AttributeSupported = TRUE;\r
+          AttributeSetting   = ImageInfoV1[Index].AttributesSetting;\r
+        }\r
+      } else if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2) {\r
+        if (ImageInfoV2[Index].AttributesSupported != 0x0) {\r
+          AttributeSupported = TRUE;\r
+          AttributeSetting   = ImageInfoV2[Index].AttributesSetting;\r
+        }\r
+      } else {\r
+        if (ImageInfo[Index].AttributesSupported != 0x0) {\r
+          AttributeSupported = TRUE;\r
+          AttributeSetting   = ImageInfo[Index].AttributesSetting;\r
+        }\r

       }\r
       }\r

-      TempRetVal = CatSPrint (RetVal, TempStr, (GuidIndex + 1), InfoTypesBuffer[GuidIndex]);\r
-      SHELL_FREE_NON_NULL (RetVal);\r
-      RetVal = TempRetVal;\r
-      SHELL_FREE_NON_NULL (TempStr);\r

 \r
 \r

-      TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_GUID_STRING), NULL);\r
-      if (TempStr == NULL) {\r
-        goto ERROR_EXIT;\r
+      if (!AttributeSupported) {\r
+        AttributeSettingStr = CatSPrint (NULL, L"None");\r
+      } else {\r
+        AttributeSettingStr = CatSPrint (NULL, L"(");\r
+\r
+        if ((AttributeSetting & IMAGE_ATTRIBUTE_IMAGE_UPDATABLE) != 0x0) {\r
+          TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_IMAGE_UPDATABLE");\r
+          SHELL_FREE_NON_NULL (AttributeSettingStr);\r
+          AttributeSettingStr = TempRetVal;\r
+        }\r
+        if ((AttributeSetting & IMAGE_ATTRIBUTE_RESET_REQUIRED) != 0x0) {\r
+          TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_RESET_REQUIRED");\r
+          SHELL_FREE_NON_NULL (AttributeSettingStr);\r
+          AttributeSettingStr = TempRetVal;\r
+        }\r
+        if ((AttributeSetting & IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED) != 0x0) {\r
+          TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED");\r
+          SHELL_FREE_NON_NULL (AttributeSettingStr);\r
+          AttributeSettingStr = TempRetVal;\r
+        }\r
+        if ((AttributeSetting & IMAGE_ATTRIBUTE_IN_USE) != 0x0) {\r
+          TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_IN_USE");\r
+          SHELL_FREE_NON_NULL (AttributeSettingStr);\r
+          AttributeSettingStr = TempRetVal;\r
+        }\r
+        if ((AttributeSetting & IMAGE_ATTRIBUTE_UEFI_IMAGE) != 0x0) {\r
+          TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_UEFI_IMAGE");\r
+          SHELL_FREE_NON_NULL (AttributeSettingStr);\r
+          AttributeSettingStr = TempRetVal;\r
+        }\r
+        TempRetVal = CatSPrint (AttributeSettingStr, L" )");\r
+        SHELL_FREE_NON_NULL (AttributeSettingStr);\r
+        AttributeSettingStr = TempRetVal;\r

       }\r
 \r
       }\r
 \r

-      if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoMediaStateGuid)) {\r
-        TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoMediaStateGuid");\r
-        SHELL_FREE_NON_NULL (RetVal);\r
-        RetVal = TempRetVal;\r
-      } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoNetworkBootGuid)) {\r
-        TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoNetworkBootGuid");\r
+      if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1) {\r
+        if (ImageInfoV1[Index].ImageIndex != 0x0) {\r
+          ImageCount++;\r
+        }\r
+\r
+        TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_IMAGE_DESCRIPTOR_INFO_V1), NULL);\r
+        if (TempStr == NULL) {\r
+          goto ERROR_EXIT;\r
+        }\r
+        TempRetVal = CatSPrint (\r
+                       RetVal,\r
+                       TempStr,\r
+                       Index,\r
+                       ImageInfoV1[Index].ImageIndex,\r
+                       &ImageInfoV1[Index].ImageTypeId,\r
+                       ImageInfoV1[Index].ImageId,\r
+                       ImageInfoV1[Index].ImageIdName,\r
+                       ImageInfoV1[Index].Version,\r
+                       ImageInfoV1[Index].VersionName,\r
+                       ImageInfoV1[Index].Size,\r
+                       ImageInfoV1[Index].AttributesSupported,\r
+                       AttributeSettingStr,\r
+                       ImageInfoV1[Index].Compatibilities\r
+                       );\r

         SHELL_FREE_NON_NULL (RetVal);\r
         RetVal = TempRetVal;\r
         SHELL_FREE_NON_NULL (RetVal);\r
         RetVal = TempRetVal;\r

-      } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoSanMacAddressGuid)) {\r
-        TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoSanMacAddressGuid");\r
+        SHELL_FREE_NON_NULL (TempStr);\r
+      } else if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2) {\r
+        if (ImageInfoV2[Index].ImageIndex != 0x0) {\r
+          ImageCount++;\r
+        }\r
+\r
+        TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_IMAGE_DESCRIPTOR_INFO_V2), NULL);\r
+        if (TempStr == NULL) {\r
+          goto ERROR_EXIT;\r
+        }\r
+        TempRetVal = CatSPrint (\r
+                       RetVal,\r
+                       TempStr,\r
+                       Index,\r
+                       ImageInfoV2[Index].ImageIndex,\r
+                       &ImageInfoV2[Index].ImageTypeId,\r
+                       ImageInfoV2[Index].ImageId,\r
+                       ImageInfoV2[Index].ImageIdName,\r
+                       ImageInfoV2[Index].Version,\r
+                       ImageInfoV2[Index].VersionName,\r
+                       ImageInfoV2[Index].Size,\r
+                       ImageInfoV2[Index].AttributesSupported,\r
+                       AttributeSettingStr,\r
+                       ImageInfoV2[Index].Compatibilities,\r
+                       ImageInfoV2[Index].LowestSupportedImageVersion\r
+                       );\r

         SHELL_FREE_NON_NULL (RetVal);\r
         RetVal = TempRetVal;\r
         SHELL_FREE_NON_NULL (RetVal);\r
         RetVal = TempRetVal;\r

+        SHELL_FREE_NON_NULL (TempStr);\r

       } else {\r
       } else {\r

-\r
-        GuidStr = GetStringNameFromGuid (&InfoTypesBuffer[GuidIndex], NULL);\r
-\r
-        if (GuidStr != NULL) {\r
-          if (StrCmp(GuidStr, L"UnknownDevice") == 0) {\r
-            TempRetVal = CatSPrint (RetVal, TempStr, L"UnknownInfoType");\r
-            SHELL_FREE_NON_NULL (RetVal);\r
-            RetVal = TempRetVal;\r
-\r
-            SHELL_FREE_NON_NULL (TempStr);\r
-            SHELL_FREE_NON_NULL(GuidStr);\r
-            //\r
-            // So that we never have to pass this UnknownInfoType to the parsing function "GetInformation" service of AIP\r
-            //\r
-            continue;\r
-          } else {\r
-            TempRetVal = CatSPrint (RetVal, TempStr, GuidStr);\r
-            SHELL_FREE_NON_NULL (RetVal);\r
-            RetVal = TempRetVal;\r
-            SHELL_FREE_NON_NULL(GuidStr);\r
-          }\r
+        if (ImageInfo[Index].ImageIndex != 0x0) {\r
+          ImageCount++;\r

         }\r
         }\r

-      }\r
-\r
-      SHELL_FREE_NON_NULL (TempStr);\r
-\r
-      Status = EfiAdptrInfoProtocol->GetInformation (\r
-                                       EfiAdptrInfoProtocol,\r
-                                       &InfoTypesBuffer[GuidIndex],\r
-                                       &InformationBlock,\r
-                                       &InformationBlockSize\r
-                                       );\r

 \r
 \r

-      if (EFI_ERROR (Status)) {\r
-        TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_GETINFO_FAILED), NULL);\r
+        TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_IMAGE_DESCRIPTOR_INFO), NULL);\r

         if (TempStr == NULL) {\r
           goto ERROR_EXIT;\r
         }\r
         if (TempStr == NULL) {\r
           goto ERROR_EXIT;\r
         }\r

-        TempRetVal = CatSPrint (RetVal, TempStr, Status);\r
+        TempRetVal = CatSPrint (\r
+                       RetVal,\r
+                       TempStr,\r
+                       Index,\r
+                       ImageInfo[Index].ImageIndex,\r
+                       &ImageInfo[Index].ImageTypeId,\r
+                       ImageInfo[Index].ImageId,\r
+                       ImageInfo[Index].ImageIdName,\r
+                       ImageInfo[Index].Version,\r
+                       ImageInfo[Index].VersionName,\r
+                       ImageInfo[Index].Size,\r
+                       ImageInfo[Index].AttributesSupported,\r
+                       AttributeSettingStr,\r
+                       ImageInfo[Index].Compatibilities,\r
+                       ImageInfo[Index].LowestSupportedImageVersion,\r
+                       ImageInfo[Index].LastAttemptVersion,\r
+                       ImageInfo[Index].LastAttemptStatus,\r
+                       ImageInfo[Index].HardwareInstance\r
+                       );\r

         SHELL_FREE_NON_NULL (RetVal);\r
         RetVal = TempRetVal;\r
         SHELL_FREE_NON_NULL (RetVal);\r
         RetVal = TempRetVal;\r

-      } else {\r
-        if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoMediaStateGuid)) {\r
-          TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_MEDIA_STATE), NULL);\r
-          if (TempStr == NULL) {\r
-            goto ERROR_EXIT;\r
-          }\r
-          TempRetVal = CatSPrint (\r
-                         RetVal,\r
-                         TempStr,\r
-                         ((EFI_ADAPTER_INFO_MEDIA_STATE *)InformationBlock)->MediaState,\r
-                         ((EFI_ADAPTER_INFO_MEDIA_STATE *)InformationBlock)->MediaState\r
-                         );\r
-          SHELL_FREE_NON_NULL (RetVal);\r
-          RetVal = TempRetVal;\r
-        } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoNetworkBootGuid)) {\r
-          TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_NETWORK_BOOT_INFO), NULL);\r
-          if (TempStr == NULL) {\r
-            goto ERROR_EXIT;\r
+        SHELL_FREE_NON_NULL (TempStr);\r
+      }\r
+    }\r
+  }\r
+\r
+  if (ImageCount > 0) {\r
+    for (Index=0; Index<DescriptorCount; Index++) {\r
+      for (Index1=Index+1; Index1<DescriptorCount; Index1++) {\r
+        if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1) {\r
+          if (ImageInfoV1[Index].ImageId == ImageInfoV1[Index1].ImageId) {\r
+            Found = TRUE;\r
+            //\r
+            // At least one match found indicating presense of non unique ImageId values so no more comparisons needed\r
+            //\r
+            goto ENDLOOP;\r

           }\r
           }\r

-          TempRetVal = CatSPrint (\r
-                         RetVal,\r
-                         TempStr,\r
-                         ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiIpv4BootCapablity,\r
-                         ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiIpv6BootCapablity,\r
-                         ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->FCoeBootCapablity,\r
-                         ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->OffloadCapability,\r
-                         ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiMpioCapability,\r
-                         ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiIpv4Boot,\r
-                         ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiIpv6Boot,\r
-                         ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->FCoeBoot\r
-                         );\r
-          SHELL_FREE_NON_NULL (RetVal);\r
-          RetVal = TempRetVal;\r
-        } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoSanMacAddressGuid) == TRUE) {\r
-          TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_SAN_MAC_ADDRESS_INFO), NULL);\r
-          if (TempStr == NULL) {\r
-            goto ERROR_EXIT;\r
+        } else if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2) {\r
+          if (ImageInfoV2[Index].ImageId == ImageInfoV2[Index1].ImageId) {\r
+            Found = TRUE;\r
+            //\r
+            // At least one match found indicating presense of non unique ImageId values so no more comparisons needed\r
+            //\r
+            goto ENDLOOP;\r

           }\r
           }\r

-          TempRetVal = CatSPrint (\r
-                         RetVal,\r
-                         TempStr,\r
-                         ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[0],\r
-                         ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[1],\r
-                         ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[2],\r
-                         ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[3],\r
-                         ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[4],\r
-                         ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[5]\r
-                         );\r
-          SHELL_FREE_NON_NULL (RetVal);\r
-          RetVal = TempRetVal;\r

         } else {\r
         } else {\r

-          TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_UNKNOWN_INFO_TYPE), NULL);\r
-          if (TempStr == NULL) {\r
-            goto ERROR_EXIT;\r
+          if (ImageInfo[Index].ImageId == ImageInfo[Index1].ImageId) {\r
+            Found = TRUE;\r
+            //\r
+            // At least one match found indicating presense of non unique ImageId values so no more comparisons needed\r
+            //\r
+            goto ENDLOOP;\r

           }\r
           }\r

-          TempRetVal = CatSPrint (RetVal, TempStr, &InfoTypesBuffer[GuidIndex]);\r
-          SHELL_FREE_NON_NULL (RetVal);\r
-          RetVal = TempRetVal;\r

         }\r
       }\r
         }\r
       }\r

-      SHELL_FREE_NON_NULL (TempStr);\r
-      SHELL_FREE_NON_NULL (InformationBlock);\r

     }\r
   }\r
 \r
     }\r
   }\r
 \r

-  SHELL_FREE_NON_NULL (InfoTypesBuffer);\r
+ENDLOOP:\r
+  //\r
+  // Check if ImageId with duplicate value was found\r
+  //\r
+  if (Found) {\r
+    TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_IMAGEID_NON_UNIQUE), NULL);\r
+    if (TempStr == NULL) {\r
+      goto ERROR_EXIT;\r
+    }\r
+    TempRetVal = CatSPrint (RetVal, TempStr);\r
+    SHELL_FREE_NON_NULL (RetVal);\r
+    RetVal = TempRetVal;\r
+    SHELL_FREE_NON_NULL (TempStr);\r
+  }\r
+\r
+  SHELL_FREE_NON_NULL (ImageInfo);\r
+  SHELL_FREE_NON_NULL (PackageVersionName);\r
+  SHELL_FREE_NON_NULL (AttributeSettingStr);\r
+\r

   return RetVal;\r
 \r
 ERROR_EXIT:\r
   SHELL_FREE_NON_NULL (RetVal);\r
   return RetVal;\r
 \r
 ERROR_EXIT:\r
   SHELL_FREE_NON_NULL (RetVal);\r

-  SHELL_FREE_NON_NULL (InfoTypesBuffer);\r
-  SHELL_FREE_NON_NULL (InformationBlock);\r
+  SHELL_FREE_NON_NULL (ImageInfo);\r
+  SHELL_FREE_NON_NULL (PackageVersionName);\r
+  SHELL_FREE_NON_NULL (AttributeSettingStr);\r
+\r

   return NULL;\r
 }\r
   return NULL;\r
 }\r

+\r
+/**\r
+  Function to dump information about Partition Information protocol.\r
+\r
+  This will allocate the return buffer from boot services pool.\r
+\r
+  @param[in] TheHandle      The handle that has the protocol installed.\r
+  @param[in] Verbose        TRUE for additional information, FALSE otherwise.\r
+\r
+  @retval A pointer to a string containing the information.\r
+**/\r
+CHAR16*\r
+EFIAPI\r
+PartitionInfoProtocolDumpInformation (\r
+  IN CONST EFI_HANDLE TheHandle,\r
+  IN CONST BOOLEAN    Verbose\r
+  )\r
+{\r
+  EFI_STATUS                      Status;\r
+  EFI_PARTITION_INFO_PROTOCOL     *PartitionInfo;\r
+  CHAR16                          *PartitionType;\r
+  CHAR16                          *EfiSystemPartition;\r
+  CHAR16                          *RetVal;\r
+\r
+  if (!Verbose) {\r
+    return NULL;\r
+  }\r
+\r
+  Status = gBS->OpenProtocol (\r
+                TheHandle,\r
+                &gEfiPartitionInfoProtocolGuid,\r
+                (VOID**)&PartitionInfo,\r
+                gImageHandle,\r
+                NULL,\r
+                EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+                );\r
+  if (EFI_ERROR (Status)) {\r
+    return NULL;\r
+  }\r
+\r
+  HandleParsingHiiInit ();\r
+\r
+  switch (PartitionInfo->Type) {\r
+  case PARTITION_TYPE_OTHER:\r
+    PartitionType = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_PARTINFO_DUMP_TYPE_OTHER), NULL);\r
+    break;\r
+  case PARTITION_TYPE_MBR:\r
+    PartitionType = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_PARTINFO_DUMP_TYPE_MBR), NULL);\r
+    break;\r
+  case PARTITION_TYPE_GPT:\r
+    PartitionType = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_PARTINFO_DUMP_TYPE_GPT), NULL);\r
+    break;\r
+  default:\r
+    PartitionType = NULL;\r
+    break;\r
+  }\r
+  if (PartitionType == NULL) {\r
+    return NULL;\r
+  }\r
+\r
+  if (PartitionInfo->System == 1) {\r
+    EfiSystemPartition = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_PARTINFO_DUMP_EFI_SYS_PART), NULL);\r
+  } else {\r
+    EfiSystemPartition = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_PARTINFO_DUMP_NOT_EFI_SYS_PART), NULL);\r
+  }\r
+  if (EfiSystemPartition == NULL) {\r
+    SHELL_FREE_NON_NULL (PartitionType);\r
+    return NULL;\r
+  }\r
+\r
+  RetVal = CatSPrint (\r
+             NULL,\r
+             L"%s\r\n%s",\r
+             PartitionType,\r
+             EfiSystemPartition\r
+             );\r
+\r
+  SHELL_FREE_NON_NULL (EfiSystemPartition);\r
+  SHELL_FREE_NON_NULL (PartitionType);\r
+  return RetVal;\r
+}\r
+\r

 //\r
 // Put the information on the NT32 protocol GUIDs here so we are not dependant on the Nt32Pkg\r
 //\r
 //\r
 // Put the information on the NT32 protocol GUIDs here so we are not dependant on the Nt32Pkg\r
 //\r


@@ -846,13 +2046,13 @@ STATIC CONST GUID_INFO_BLOCK mGuidStringListNT[] = {
   {STRING_TOKEN(STR_WINNT_THUNK),           (EFI_GUID*)&WinNtThunkProtocolGuid,               NULL},\r
   {STRING_TOKEN(STR_WINNT_DRIVER_IO),       (EFI_GUID*)&WinNtIoProtocolGuid,                  NULL},\r
   {STRING_TOKEN(STR_WINNT_SERIAL_PORT),     (EFI_GUID*)&WinNtSerialPortGuid,                  NULL},\r
   {STRING_TOKEN(STR_WINNT_THUNK),           (EFI_GUID*)&WinNtThunkProtocolGuid,               NULL},\r
   {STRING_TOKEN(STR_WINNT_DRIVER_IO),       (EFI_GUID*)&WinNtIoProtocolGuid,                  NULL},\r
   {STRING_TOKEN(STR_WINNT_SERIAL_PORT),     (EFI_GUID*)&WinNtSerialPortGuid,                  NULL},\r

-  {STRING_TOKEN(STR_UNKNOWN_DEVICE),        NULL,                                             NULL},\r
+  {0,                                       NULL,                                             NULL},\r

 };\r
 \r
 STATIC CONST GUID_INFO_BLOCK mGuidStringList[] = {\r
   {STRING_TOKEN(STR_LOADED_IMAGE),          &gEfiLoadedImageProtocolGuid,                     LoadedImageProtocolDumpInformation},\r
   {STRING_TOKEN(STR_DEVICE_PATH),           &gEfiDevicePathProtocolGuid,                      DevicePathProtocolDumpInformation},\r
 };\r
 \r
 STATIC CONST GUID_INFO_BLOCK mGuidStringList[] = {\r
   {STRING_TOKEN(STR_LOADED_IMAGE),          &gEfiLoadedImageProtocolGuid,                     LoadedImageProtocolDumpInformation},\r
   {STRING_TOKEN(STR_DEVICE_PATH),           &gEfiDevicePathProtocolGuid,                      DevicePathProtocolDumpInformation},\r

-  {STRING_TOKEN(STR_IMAGE_PATH),            &gEfiLoadedImageDevicePathProtocolGuid,           DevicePathProtocolDumpInformation},\r
+  {STRING_TOKEN(STR_IMAGE_PATH),            &gEfiLoadedImageDevicePathProtocolGuid,           LoadedImageDevicePathProtocolDumpInformation},\r

   {STRING_TOKEN(STR_DEVICE_PATH_UTIL),      &gEfiDevicePathUtilitiesProtocolGuid,             NULL},\r
   {STRING_TOKEN(STR_DEVICE_PATH_TXT),       &gEfiDevicePathToTextProtocolGuid,                NULL},\r
   {STRING_TOKEN(STR_DEVICE_PATH_FTXT),      &gEfiDevicePathFromTextProtocolGuid,              NULL},\r
   {STRING_TOKEN(STR_DEVICE_PATH_UTIL),      &gEfiDevicePathUtilitiesProtocolGuid,             NULL},\r
   {STRING_TOKEN(STR_DEVICE_PATH_TXT),       &gEfiDevicePathToTextProtocolGuid,                NULL},\r
   {STRING_TOKEN(STR_DEVICE_PATH_FTXT),      &gEfiDevicePathFromTextProtocolGuid,              NULL},\r


@@ -862,7 +2062,7 @@ STATIC CONST GUID_INFO_BLOCK mGuidStringList[] = {
   {STRING_TOKEN(STR_DEVICE_PATH_VTUTF8),    &gEfiVTUTF8Guid,                                  NULL},\r
   {STRING_TOKEN(STR_DRIVER_BINDING),        &gEfiDriverBindingProtocolGuid,                   NULL},\r
   {STRING_TOKEN(STR_PLATFORM_OVERRIDE),     &gEfiPlatformDriverOverrideProtocolGuid,          NULL},\r
   {STRING_TOKEN(STR_DEVICE_PATH_VTUTF8),    &gEfiVTUTF8Guid,                                  NULL},\r
   {STRING_TOKEN(STR_DRIVER_BINDING),        &gEfiDriverBindingProtocolGuid,                   NULL},\r
   {STRING_TOKEN(STR_PLATFORM_OVERRIDE),     &gEfiPlatformDriverOverrideProtocolGuid,          NULL},\r

-  {STRING_TOKEN(STR_BUS_OVERRIDE),          &gEfiBusSpecificDriverOverrideProtocolGuid,       NULL},\r
+  {STRING_TOKEN(STR_BUS_OVERRIDE),          &gEfiBusSpecificDriverOverrideProtocolGuid,       BusSpecificDriverOverrideProtocolDumpInformation},\r

   {STRING_TOKEN(STR_DRIVER_DIAG),           &gEfiDriverDiagnosticsProtocolGuid,               NULL},\r
   {STRING_TOKEN(STR_DRIVER_DIAG2),          &gEfiDriverDiagnostics2ProtocolGuid,              NULL},\r
   {STRING_TOKEN(STR_DRIVER_CN),             &gEfiComponentNameProtocolGuid,                   NULL},\r
   {STRING_TOKEN(STR_DRIVER_DIAG),           &gEfiDriverDiagnosticsProtocolGuid,               NULL},\r
   {STRING_TOKEN(STR_DRIVER_DIAG2),          &gEfiDriverDiagnostics2ProtocolGuid,              NULL},\r
   {STRING_TOKEN(STR_DRIVER_CN),             &gEfiComponentNameProtocolGuid,                   NULL},\r


@@ -876,8 +2076,8 @@ STATIC CONST GUID_INFO_BLOCK mGuidStringList[] = {
   {STRING_TOKEN(STR_ABS_POINTER),           &gEfiAbsolutePointerProtocolGuid,                 NULL},\r
   {STRING_TOKEN(STR_SERIAL_IO),             &gEfiSerialIoProtocolGuid,                        NULL},\r
   {STRING_TOKEN(STR_GRAPHICS_OUTPUT),       &gEfiGraphicsOutputProtocolGuid,                  GraphicsOutputProtocolDumpInformation},\r
   {STRING_TOKEN(STR_ABS_POINTER),           &gEfiAbsolutePointerProtocolGuid,                 NULL},\r
   {STRING_TOKEN(STR_SERIAL_IO),             &gEfiSerialIoProtocolGuid,                        NULL},\r
   {STRING_TOKEN(STR_GRAPHICS_OUTPUT),       &gEfiGraphicsOutputProtocolGuid,                  GraphicsOutputProtocolDumpInformation},\r

-  {STRING_TOKEN(STR_EDID_DISCOVERED),       &gEfiEdidDiscoveredProtocolGuid,                  NULL},\r
-  {STRING_TOKEN(STR_EDID_ACTIVE),           &gEfiEdidActiveProtocolGuid,                      NULL},\r
+  {STRING_TOKEN(STR_EDID_DISCOVERED),       &gEfiEdidDiscoveredProtocolGuid,                  EdidDiscoveredProtocolDumpInformation},\r
+  {STRING_TOKEN(STR_EDID_ACTIVE),           &gEfiEdidActiveProtocolGuid,                      EdidActiveProtocolDumpInformation},\r

   {STRING_TOKEN(STR_EDID_OVERRIDE),         &gEfiEdidOverrideProtocolGuid,                    NULL},\r
   {STRING_TOKEN(STR_CON_IN),                &gEfiConsoleInDeviceGuid,                         NULL},\r
   {STRING_TOKEN(STR_CON_OUT),               &gEfiConsoleOutDeviceGuid,                        NULL},\r
   {STRING_TOKEN(STR_EDID_OVERRIDE),         &gEfiEdidOverrideProtocolGuid,                    NULL},\r
   {STRING_TOKEN(STR_CON_IN),                &gEfiConsoleInDeviceGuid,                         NULL},\r
   {STRING_TOKEN(STR_CON_OUT),               &gEfiConsoleOutDeviceGuid,                        NULL},\r


@@ -887,19 +2087,19 @@ STATIC CONST GUID_INFO_BLOCK mGuidStringList[] = {
   {STRING_TOKEN(STR_SIMPLE_FILE_SYS),       &gEfiSimpleFileSystemProtocolGuid,                NULL},\r
   {STRING_TOKEN(STR_TAPE_IO),               &gEfiTapeIoProtocolGuid,                          NULL},\r
   {STRING_TOKEN(STR_DISK_IO),               &gEfiDiskIoProtocolGuid,                          NULL},\r
   {STRING_TOKEN(STR_SIMPLE_FILE_SYS),       &gEfiSimpleFileSystemProtocolGuid,                NULL},\r
   {STRING_TOKEN(STR_TAPE_IO),               &gEfiTapeIoProtocolGuid,                          NULL},\r
   {STRING_TOKEN(STR_DISK_IO),               &gEfiDiskIoProtocolGuid,                          NULL},\r

-  {STRING_TOKEN(STR_BLK_IO),                &gEfiBlockIoProtocolGuid,                         NULL},\r
+  {STRING_TOKEN(STR_BLK_IO),                &gEfiBlockIoProtocolGuid,                         BlockIoProtocolDumpInformation},\r

   {STRING_TOKEN(STR_UC),                    &gEfiUnicodeCollationProtocolGuid,                NULL},\r
   {STRING_TOKEN(STR_UC2),                   &gEfiUnicodeCollation2ProtocolGuid,               NULL},\r
   {STRING_TOKEN(STR_PCIRB_IO),              &gEfiPciRootBridgeIoProtocolGuid,                 PciRootBridgeIoDumpInformation},\r
   {STRING_TOKEN(STR_UC),                    &gEfiUnicodeCollationProtocolGuid,                NULL},\r
   {STRING_TOKEN(STR_UC2),                   &gEfiUnicodeCollation2ProtocolGuid,               NULL},\r
   {STRING_TOKEN(STR_PCIRB_IO),              &gEfiPciRootBridgeIoProtocolGuid,                 PciRootBridgeIoDumpInformation},\r

-  {STRING_TOKEN(STR_PCI_IO),                &gEfiPciIoProtocolGuid,                           NULL},\r
+  {STRING_TOKEN(STR_PCI_IO),                &gEfiPciIoProtocolGuid,                           PciIoProtocolDumpInformation},\r

   {STRING_TOKEN(STR_SCSI_PT),               &gEfiScsiPassThruProtocolGuid,                    NULL},\r
   {STRING_TOKEN(STR_SCSI_IO),               &gEfiScsiIoProtocolGuid,                          NULL},\r
   {STRING_TOKEN(STR_SCSI_PT_EXT),           &gEfiExtScsiPassThruProtocolGuid,                 NULL},\r
   {STRING_TOKEN(STR_ISCSI),                 &gEfiIScsiInitiatorNameProtocolGuid,              NULL},\r
   {STRING_TOKEN(STR_SCSI_PT),               &gEfiScsiPassThruProtocolGuid,                    NULL},\r
   {STRING_TOKEN(STR_SCSI_IO),               &gEfiScsiIoProtocolGuid,                          NULL},\r
   {STRING_TOKEN(STR_SCSI_PT_EXT),           &gEfiExtScsiPassThruProtocolGuid,                 NULL},\r
   {STRING_TOKEN(STR_ISCSI),                 &gEfiIScsiInitiatorNameProtocolGuid,              NULL},\r

-  {STRING_TOKEN(STR_USB_IO),                &gEfiUsbIoProtocolGuid,                           NULL},\r
+  {STRING_TOKEN(STR_USB_IO),                &gEfiUsbIoProtocolGuid,                           UsbIoProtocolDumpInformation},\r

   {STRING_TOKEN(STR_USB_HC),                &gEfiUsbHcProtocolGuid,                           NULL},\r
   {STRING_TOKEN(STR_USB_HC2),               &gEfiUsb2HcProtocolGuid,                          NULL},\r
   {STRING_TOKEN(STR_USB_HC),                &gEfiUsbHcProtocolGuid,                           NULL},\r
   {STRING_TOKEN(STR_USB_HC2),               &gEfiUsb2HcProtocolGuid,                          NULL},\r

-  {STRING_TOKEN(STR_DEBUG_SUPPORT),         &gEfiDebugSupportProtocolGuid,                    NULL},\r
+  {STRING_TOKEN(STR_DEBUG_SUPPORT),         &gEfiDebugSupportProtocolGuid,                    DebugSupportProtocolDumpInformation},\r

   {STRING_TOKEN(STR_DEBUG_PORT),            &gEfiDebugPortProtocolGuid,                       NULL},\r
   {STRING_TOKEN(STR_DECOMPRESS),            &gEfiDecompressProtocolGuid,                      NULL},\r
   {STRING_TOKEN(STR_ACPI_TABLE),            &gEfiAcpiTableProtocolGuid,                       NULL},\r
   {STRING_TOKEN(STR_DEBUG_PORT),            &gEfiDebugPortProtocolGuid,                       NULL},\r
   {STRING_TOKEN(STR_DECOMPRESS),            &gEfiDecompressProtocolGuid,                      NULL},\r
   {STRING_TOKEN(STR_ACPI_TABLE),            &gEfiAcpiTableProtocolGuid,                       NULL},\r


@@ -1001,7 +2201,7 @@ STATIC CONST GUID_INFO_BLOCK mGuidStringList[] = {
 //\r
 // UEFI 2.3\r
 //\r
 //\r
 // UEFI 2.3\r
 //\r

-  {STRING_TOKEN(STR_FW_MGMT),               &gEfiFirmwareManagementProtocolGuid,              NULL},\r
+  {STRING_TOKEN(STR_FW_MGMT),               &gEfiFirmwareManagementProtocolGuid,              FirmwareManagementDumpInformation},\r

   {STRING_TOKEN(STR_IP_SEC),                &gEfiIpSecProtocolGuid,                           NULL},\r
   {STRING_TOKEN(STR_IP_SEC2),               &gEfiIpSec2ProtocolGuid,                          NULL},\r
 \r
   {STRING_TOKEN(STR_IP_SEC),                &gEfiIpSecProtocolGuid,                           NULL},\r
   {STRING_TOKEN(STR_IP_SEC2),               &gEfiIpSec2ProtocolGuid,                          NULL},\r
 \r


@@ -1019,12 +2219,168 @@ STATIC CONST GUID_INFO_BLOCK mGuidStringList[] = {
   {STRING_TOKEN(STR_DISK_IO2),              &gEfiDiskIo2ProtocolGuid,                         NULL},\r
   {STRING_TOKEN(STR_ADAPTER_INFO),          &gEfiAdapterInformationProtocolGuid,              AdapterInformationDumpInformation},\r
 \r
   {STRING_TOKEN(STR_DISK_IO2),              &gEfiDiskIo2ProtocolGuid,                         NULL},\r
   {STRING_TOKEN(STR_ADAPTER_INFO),          &gEfiAdapterInformationProtocolGuid,              AdapterInformationDumpInformation},\r
 \r

+//\r
+// UEFI2.5\r
+//\r
+  {STRING_TOKEN(STR_TLS_SB),                &gEfiTlsServiceBindingProtocolGuid,              NULL},\r
+  {STRING_TOKEN(STR_TLS),                   &gEfiTlsProtocolGuid,                            NULL},\r
+  {STRING_TOKEN(STR_TLS_CONFIG),            &gEfiTlsConfigurationProtocolGuid,               NULL},\r
+  {STRING_TOKEN(STR_SUPPLICANT_SB),         &gEfiSupplicantServiceBindingProtocolGuid,       NULL},\r
+  {STRING_TOKEN(STR_SUPPLICANT),            &gEfiSupplicantProtocolGuid,                     NULL},\r
+\r
+//\r
+// UEFI2.6\r
+//\r
+  {STRING_TOKEN(STR_WIFI2),                 &gEfiWiFi2ProtocolGuid,                          NULL},\r
+  {STRING_TOKEN(STR_RAMDISK),               &gEfiRamDiskProtocolGuid,                        NULL},\r
+  {STRING_TOKEN(STR_HII_ID),                &gEfiHiiImageDecoderProtocolGuid,                NULL},\r
+  {STRING_TOKEN(STR_HII_IE),                &gEfiHiiImageExProtocolGuid,                     NULL},\r
+  {STRING_TOKEN(STR_SD_MPT),                &gEfiSdMmcPassThruProtocolGuid,                  NULL},\r
+  {STRING_TOKEN(STR_ERASE_BLOCK),           &gEfiEraseBlockProtocolGuid,                     NULL},\r
+\r
+//\r
+// UEFI2.7\r
+//\r
+  {STRING_TOKEN(STR_BLUETOOTH_ATTR),        &gEfiBluetoothAttributeProtocolGuid,               NULL},\r
+  {STRING_TOKEN(STR_BLUETOOTH_ATTR_SB),     &gEfiBluetoothAttributeServiceBindingProtocolGuid, NULL},\r
+  {STRING_TOKEN(STR_BLUETOOTH_LE_CONFIG),   &gEfiBluetoothLeConfigProtocolGuid,                NULL},\r
+  {STRING_TOKEN(STR_UFS_DEV_CONFIG),        &gEfiUfsDeviceConfigProtocolGuid,                  NULL},\r
+  {STRING_TOKEN(STR_HTTP_BOOT_CALL),        &gEfiHttpBootCallbackProtocolGuid,                 NULL},\r
+  {STRING_TOKEN(STR_RESET_NOTI),            &gEfiResetNotificationProtocolGuid,                NULL},\r
+  {STRING_TOKEN(STR_PARTITION_INFO),        &gEfiPartitionInfoProtocolGuid,                    PartitionInfoProtocolDumpInformation},\r
+  {STRING_TOKEN(STR_HII_POPUP),             &gEfiHiiPopupProtocolGuid,                         NULL},\r
+\r

 //\r
 // PI Spec ones\r
 //\r
   {STRING_TOKEN(STR_IDE_CONT_INIT),         &gEfiIdeControllerInitProtocolGuid,               NULL},\r
   {STRING_TOKEN(STR_DISK_INFO),             &gEfiDiskInfoProtocolGuid,                        NULL},\r
 \r
 //\r
 // PI Spec ones\r
 //\r
   {STRING_TOKEN(STR_IDE_CONT_INIT),         &gEfiIdeControllerInitProtocolGuid,               NULL},\r
   {STRING_TOKEN(STR_DISK_INFO),             &gEfiDiskInfoProtocolGuid,                        NULL},\r
 \r

+//\r
+// PI Spec 1.0\r
+//\r
+  {STRING_TOKEN(STR_BDS_ARCH),              &gEfiBdsArchProtocolGuid,                         NULL},\r
+  {STRING_TOKEN(STR_CPU_ARCH),              &gEfiCpuArchProtocolGuid,                         NULL},\r
+  {STRING_TOKEN(STR_MET_ARCH),              &gEfiMetronomeArchProtocolGuid,                   NULL},\r
+  {STRING_TOKEN(STR_MON_ARCH),              &gEfiMonotonicCounterArchProtocolGuid,            NULL},\r
+  {STRING_TOKEN(STR_RTC_ARCH),              &gEfiRealTimeClockArchProtocolGuid,               NULL},\r
+  {STRING_TOKEN(STR_RESET_ARCH),            &gEfiResetArchProtocolGuid,                       NULL},\r
+  {STRING_TOKEN(STR_RT_ARCH),               &gEfiRuntimeArchProtocolGuid,                     NULL},\r
+  {STRING_TOKEN(STR_SEC_ARCH),              &gEfiSecurityArchProtocolGuid,                    NULL},\r
+  {STRING_TOKEN(STR_TIMER_ARCH),            &gEfiTimerArchProtocolGuid,                       NULL},\r
+  {STRING_TOKEN(STR_VAR_ARCH),              &gEfiVariableWriteArchProtocolGuid,               NULL},\r
+  {STRING_TOKEN(STR_V_ARCH),                &gEfiVariableArchProtocolGuid,                    NULL},\r
+  {STRING_TOKEN(STR_SECP),                  &gEfiSecurityPolicyProtocolGuid,                  NULL},\r
+  {STRING_TOKEN(STR_WDT_ARCH),              &gEfiWatchdogTimerArchProtocolGuid,               NULL},\r
+  {STRING_TOKEN(STR_SCR),                   &gEfiStatusCodeRuntimeProtocolGuid,               NULL},\r
+  {STRING_TOKEN(STR_SMB_HC),                &gEfiSmbusHcProtocolGuid,                         NULL},\r
+  {STRING_TOKEN(STR_FV_2),                  &gEfiFirmwareVolume2ProtocolGuid,                 NULL},\r
+  {STRING_TOKEN(STR_FV_BLOCK),              &gEfiFirmwareVolumeBlockProtocolGuid,             NULL},\r
+  {STRING_TOKEN(STR_CAP_ARCH),              &gEfiCapsuleArchProtocolGuid,                     NULL},\r
+  {STRING_TOKEN(STR_MP_SERVICE),            &gEfiMpServiceProtocolGuid,                       NULL},\r
+  {STRING_TOKEN(STR_HBRAP),                 &gEfiPciHostBridgeResourceAllocationProtocolGuid, NULL},\r
+  {STRING_TOKEN(STR_PCIP),                  &gEfiPciPlatformProtocolGuid,                     NULL},\r
+  {STRING_TOKEN(STR_PCIO),                  &gEfiPciOverrideProtocolGuid,                     NULL},\r
+  {STRING_TOKEN(STR_PCIE),                  &gEfiPciEnumerationCompleteProtocolGuid,          NULL},\r
+  {STRING_TOKEN(STR_IPCID),                 &gEfiIncompatiblePciDeviceSupportProtocolGuid,    NULL},\r
+  {STRING_TOKEN(STR_PCIHPI),                &gEfiPciHotPlugInitProtocolGuid,                  NULL},\r
+  {STRING_TOKEN(STR_PCIHPR),                &gEfiPciHotPlugRequestProtocolGuid,               NULL},\r
+  {STRING_TOKEN(STR_SMBIOS),                &gEfiSmbiosProtocolGuid,                          NULL},\r
+  {STRING_TOKEN(STR_S3_SAVE),               &gEfiS3SaveStateProtocolGuid,                     NULL},\r
+  {STRING_TOKEN(STR_S3_S_SMM),              &gEfiS3SmmSaveStateProtocolGuid,                  NULL},\r
+  {STRING_TOKEN(STR_RSC),                   &gEfiRscHandlerProtocolGuid,                      NULL},\r
+  {STRING_TOKEN(STR_S_RSC),                 &gEfiSmmRscHandlerProtocolGuid,                   NULL},\r
+  {STRING_TOKEN(STR_ACPI_SDT),              &gEfiAcpiSdtProtocolGuid,                         NULL},\r
+  {STRING_TOKEN(STR_SIO),                   &gEfiSioProtocolGuid,                             NULL},\r
+  {STRING_TOKEN(STR_S_CPU2),                &gEfiSmmCpuIo2ProtocolGuid,                       NULL},\r
+  {STRING_TOKEN(STR_S_BASE2),               &gEfiSmmBase2ProtocolGuid,                        NULL},\r
+  {STRING_TOKEN(STR_S_ACC_2),               &gEfiSmmAccess2ProtocolGuid,                      NULL},\r
+  {STRING_TOKEN(STR_S_CON_2),               &gEfiSmmControl2ProtocolGuid,                     NULL},\r
+  {STRING_TOKEN(STR_S_CONFIG),              &gEfiSmmConfigurationProtocolGuid,                NULL},\r
+  {STRING_TOKEN(STR_S_RTL),                 &gEfiSmmReadyToLockProtocolGuid,                  NULL},\r
+  {STRING_TOKEN(STR_DS_RTL),                &gEfiDxeSmmReadyToLockProtocolGuid,               NULL},\r
+  {STRING_TOKEN(STR_S_COMM),                &gEfiSmmCommunicationProtocolGuid,                NULL},\r
+  {STRING_TOKEN(STR_S_STAT),                &gEfiSmmStatusCodeProtocolGuid,                   NULL},\r
+  {STRING_TOKEN(STR_S_CPU),                 &gEfiSmmCpuProtocolGuid,                          NULL},\r
+  {STRING_TOKEN(STR_S_PCIRBIO),             &gEfiSmmPciRootBridgeIoProtocolGuid,              NULL},\r
+  {STRING_TOKEN(STR_S_SWD),                 &gEfiSmmSwDispatch2ProtocolGuid,                  NULL},\r
+  {STRING_TOKEN(STR_S_SXD),                 &gEfiSmmSxDispatch2ProtocolGuid,                  NULL},\r
+  {STRING_TOKEN(STR_S_PTD2),                &gEfiSmmPeriodicTimerDispatch2ProtocolGuid,       NULL},\r
+  {STRING_TOKEN(STR_S_UD2),                 &gEfiSmmUsbDispatch2ProtocolGuid,                 NULL},\r
+  {STRING_TOKEN(STR_S_GD2),                 &gEfiSmmGpiDispatch2ProtocolGuid,                 NULL},\r
+  {STRING_TOKEN(STR_S_SBD2),                &gEfiSmmStandbyButtonDispatch2ProtocolGuid,       NULL},\r
+  {STRING_TOKEN(STR_S_PBD2),                &gEfiSmmPowerButtonDispatch2ProtocolGuid,         NULL},\r
+  {STRING_TOKEN(STR_S_ITD2),                &gEfiSmmIoTrapDispatch2ProtocolGuid,              NULL},\r
+  {STRING_TOKEN(STR_PCD),                   &gEfiPcdProtocolGuid,                             NULL},\r
+  {STRING_TOKEN(STR_FVB2),                  &gEfiFirmwareVolumeBlock2ProtocolGuid,            NULL},\r
+  {STRING_TOKEN(STR_CPUIO2),                &gEfiCpuIo2ProtocolGuid,                          NULL},\r
+  {STRING_TOKEN(STR_LEGACY_R2),             &gEfiLegacyRegion2ProtocolGuid,                   NULL},\r
+  {STRING_TOKEN(STR_S2ARCH),                &gEfiSecurity2ArchProtocolGuid,                   NULL},\r
+  {STRING_TOKEN(STR_EODXE),                 &gEfiSmmEndOfDxeProtocolGuid,                     NULL},\r
+  {STRING_TOKEN(STR_ISAHC),                 &gEfiIsaHcProtocolGuid,                           NULL},\r
+  {STRING_TOKEN(STR_ISAHC_B),               &gEfiIsaHcServiceBindingProtocolGuid,             NULL},\r
+  {STRING_TOKEN(STR_SIO_C),                 &gEfiSioControlProtocolGuid,                      NULL},\r
+  {STRING_TOKEN(STR_GET_PCD),               &gEfiGetPcdInfoProtocolGuid,                      NULL},\r
+  {STRING_TOKEN(STR_I2C_M),                 &gEfiI2cMasterProtocolGuid,                       NULL},\r
+  {STRING_TOKEN(STR_I2CIO),                 &gEfiI2cIoProtocolGuid,                           NULL},\r
+  {STRING_TOKEN(STR_I2CEN),                 &gEfiI2cEnumerateProtocolGuid,                    NULL},\r
+  {STRING_TOKEN(STR_I2C_H),                 &gEfiI2cHostProtocolGuid,                         NULL},\r
+  {STRING_TOKEN(STR_I2C_BCM),               &gEfiI2cBusConfigurationManagementProtocolGuid,   NULL},\r
+  {STRING_TOKEN(STR_TCG2),                  &gEfiTcg2ProtocolGuid,                            NULL},\r
+  {STRING_TOKEN(STR_TIMESTAMP),             &gEfiTimestampProtocolGuid,                       NULL},\r
+  {STRING_TOKEN(STR_RNG),                   &gEfiRngProtocolGuid,                             NULL},\r
+  {STRING_TOKEN(STR_NVMEPT),                &gEfiNvmExpressPassThruProtocolGuid,              NULL},\r
+  {STRING_TOKEN(STR_H2_SB),                 &gEfiHash2ServiceBindingProtocolGuid,             NULL},\r
+  {STRING_TOKEN(STR_HASH2),                 &gEfiHash2ProtocolGuid,                           NULL},\r
+  {STRING_TOKEN(STR_BIO_C),                 &gEfiBlockIoCryptoProtocolGuid,                   NULL},\r
+  {STRING_TOKEN(STR_SCR),                   &gEfiSmartCardReaderProtocolGuid,                 NULL},\r
+  {STRING_TOKEN(STR_SCE),                   &gEfiSmartCardEdgeProtocolGuid,                   NULL},\r
+  {STRING_TOKEN(STR_USB_FIO),               &gEfiUsbFunctionIoProtocolGuid,                   NULL},\r
+  {STRING_TOKEN(STR_BC_HC),                 &gEfiBluetoothHcProtocolGuid,                     NULL},\r
+  {STRING_TOKEN(STR_BC_IO_SB),              &gEfiBluetoothIoServiceBindingProtocolGuid,       NULL},\r
+  {STRING_TOKEN(STR_BC_IO),                 &gEfiBluetoothIoProtocolGuid,                     NULL},\r
+  {STRING_TOKEN(STR_BC_C),                  &gEfiBluetoothConfigProtocolGuid,                 NULL},\r
+  {STRING_TOKEN(STR_REG_EXP),               &gEfiRegularExpressionProtocolGuid,               NULL},\r
+  {STRING_TOKEN(STR_B_MGR_P),               &gEfiBootManagerPolicyProtocolGuid,               NULL},\r
+  {STRING_TOKEN(STR_CKH),                   &gEfiConfigKeywordHandlerProtocolGuid,            NULL},\r
+  {STRING_TOKEN(STR_WIFI),                  &gEfiWiFiProtocolGuid,                            NULL},\r
+  {STRING_TOKEN(STR_EAP_M),                 &gEfiEapManagement2ProtocolGuid,                  NULL},\r
+  {STRING_TOKEN(STR_EAP_C),                 &gEfiEapConfigurationProtocolGuid,                NULL},\r
+  {STRING_TOKEN(STR_PKCS7),                 &gEfiPkcs7VerifyProtocolGuid,                     NULL},\r
+  {STRING_TOKEN(STR_NET_DNS4_SB),           &gEfiDns4ServiceBindingProtocolGuid,              NULL},\r
+  {STRING_TOKEN(STR_NET_DNS4),              &gEfiDns4ProtocolGuid,                            NULL},\r
+  {STRING_TOKEN(STR_NET_DNS6_SB),           &gEfiDns6ServiceBindingProtocolGuid,              NULL},\r
+  {STRING_TOKEN(STR_NET_DNS6),              &gEfiDns6ProtocolGuid,                            NULL},\r
+  {STRING_TOKEN(STR_NET_HTTP_SB),           &gEfiHttpServiceBindingProtocolGuid,              NULL},\r
+  {STRING_TOKEN(STR_NET_HTTP),              &gEfiHttpProtocolGuid,                            NULL},\r
+  {STRING_TOKEN(STR_NET_HTTP_U),            &gEfiHttpUtilitiesProtocolGuid,                   NULL},\r
+  {STRING_TOKEN(STR_REST),                  &gEfiRestProtocolGuid,                            NULL},\r
+\r
+//\r
+// PI 1.5\r
+//\r
+  {STRING_TOKEN(STR_MM_EOD),                &gEfiMmEndOfDxeProtocolGuid,                      NULL},\r
+  {STRING_TOKEN(STR_MM_ITD),                &gEfiMmIoTrapDispatchProtocolGuid,                NULL},\r
+  {STRING_TOKEN(STR_MM_PBD),                &gEfiMmPowerButtonDispatchProtocolGuid,           NULL},\r
+  {STRING_TOKEN(STR_MM_SBD),                &gEfiMmStandbyButtonDispatchProtocolGuid,         NULL},\r
+  {STRING_TOKEN(STR_MM_GD),                 &gEfiMmGpiDispatchProtocolGuid,                   NULL},\r
+  {STRING_TOKEN(STR_MM_UD),                 &gEfiMmUsbDispatchProtocolGuid,                   NULL},\r
+  {STRING_TOKEN(STR_MM_PTD),                &gEfiMmPeriodicTimerDispatchProtocolGuid,         NULL},\r
+  {STRING_TOKEN(STR_MM_SXD),                &gEfiMmSxDispatchProtocolGuid,                    NULL},\r
+  {STRING_TOKEN(STR_MM_SWD),                &gEfiMmSwDispatchProtocolGuid,                    NULL},\r
+  {STRING_TOKEN(STR_MM_PRBI),               &gEfiMmPciRootBridgeIoProtocolGuid,               NULL},\r
+  {STRING_TOKEN(STR_MM_CPU),                &gEfiMmCpuProtocolGuid,                           NULL},\r
+  {STRING_TOKEN(STR_MM_STACODE),            &gEfiMmStatusCodeProtocolGuid,                    NULL},\r
+  {STRING_TOKEN(STR_DXEMM_RTL),             &gEfiDxeMmReadyToLockProtocolGuid,                NULL},\r
+  {STRING_TOKEN(STR_MM_CONFIG),             &gEfiMmConfigurationProtocolGuid,                 NULL},\r
+  {STRING_TOKEN(STR_MM_RTL),                &gEfiMmReadyToLockProtocolGuid,                   NULL},\r
+  {STRING_TOKEN(STR_MM_CONTROL),            &gEfiMmControlProtocolGuid,                       NULL},\r
+  {STRING_TOKEN(STR_MM_ACCESS),             &gEfiMmAccessProtocolGuid,                        NULL},\r
+  {STRING_TOKEN(STR_MM_BASE),               &gEfiMmBaseProtocolGuid,                          NULL},\r
+  {STRING_TOKEN(STR_MM_CPUIO),              &gEfiMmCpuIoProtocolGuid,                         NULL},\r
+  {STRING_TOKEN(STR_MM_RH),                 &gEfiMmRscHandlerProtocolGuid,                    NULL},\r
+  {STRING_TOKEN(STR_MM_COM),                &gEfiMmCommunicationProtocolGuid,                 NULL},\r
+\r

 //\r
 // UEFI Shell Spec 2.0\r
 //\r
 //\r
 // UEFI Shell Spec 2.0\r
 //\r


@@ -1036,10 +2392,15 @@ STATIC CONST GUID_INFO_BLOCK mGuidStringList[] = {
 //\r
   {STRING_TOKEN(STR_SHELL_DYNAMIC),         &gEfiShellDynamicCommandProtocolGuid,             NULL},\r
 \r
 //\r
   {STRING_TOKEN(STR_SHELL_DYNAMIC),         &gEfiShellDynamicCommandProtocolGuid,             NULL},\r
 \r

+//\r
+// Misc\r
+//\r
+  {STRING_TOKEN(STR_PCDINFOPROT),           &gGetPcdInfoProtocolGuid,                         NULL},\r
+\r

 //\r
 // terminator\r
 //\r
 //\r
 // terminator\r
 //\r

-  {STRING_TOKEN(STR_UNKNOWN_DEVICE),        NULL,                                             NULL},\r
+  {0,                                       NULL,                                             NULL},\r

 };\r
 \r
 /**\r
 };\r
 \r
 /**\r


@@ -1052,7 +2413,6 @@ STATIC CONST GUID_INFO_BLOCK mGuidStringList[] = {
   @return                       The node.\r
 **/\r
 CONST GUID_INFO_BLOCK *\r
   @return                       The node.\r
 **/\r
 CONST GUID_INFO_BLOCK *\r

-EFIAPI\r

 InternalShellGetNodeFromGuid(\r
   IN CONST EFI_GUID* Guid\r
   )\r
 InternalShellGetNodeFromGuid(\r
   IN CONST EFI_GUID* Guid\r
   )\r


@@ -1062,7 +2422,7 @@ InternalShellGetNodeFromGuid(
 \r
   ASSERT(Guid != NULL);\r
 \r
 \r
   ASSERT(Guid != NULL);\r
 \r

-  for (LoopCount = 0, ListWalker = GuidList; GuidList != NULL && LoopCount < GuidListCount; LoopCount++, ListWalker++) {\r
+  for (LoopCount = 0, ListWalker = mGuidList; mGuidList != NULL && LoopCount < mGuidListCount; LoopCount++, ListWalker++) {\r

     if (CompareGuid(ListWalker->GuidId, Guid)) {\r
       return (ListWalker);\r
     }\r
     if (CompareGuid(ListWalker->GuidId, Guid)) {\r
       return (ListWalker);\r
     }\r


@@ -1096,7 +2456,6 @@ Function to add a new GUID/Name mapping.
 @retval EFI_INVALID_PARAMETER Guid NameId was invalid\r
 **/\r
 EFI_STATUS\r
 @retval EFI_INVALID_PARAMETER Guid NameId was invalid\r
 **/\r
 EFI_STATUS\r

-EFIAPI\r

 InsertNewGuidNameMapping(\r
   IN CONST EFI_GUID           *Guid,\r
   IN CONST EFI_STRING_ID      NameID,\r
 InsertNewGuidNameMapping(\r
   IN CONST EFI_GUID           *Guid,\r
   IN CONST EFI_STRING_ID      NameID,\r


@@ -1106,18 +2465,18 @@ InsertNewGuidNameMapping(
   ASSERT(Guid   != NULL);\r
   ASSERT(NameID != 0);\r
 \r
   ASSERT(Guid   != NULL);\r
   ASSERT(NameID != 0);\r
 \r

-  GuidList = ReallocatePool(GuidListCount * sizeof(GUID_INFO_BLOCK), GuidListCount+1 * sizeof(GUID_INFO_BLOCK), GuidList);\r
-  if (GuidList == NULL) {\r
-    GuidListCount = 0;\r
+  mGuidList = ReallocatePool(mGuidListCount * sizeof(GUID_INFO_BLOCK), mGuidListCount+1 * sizeof(GUID_INFO_BLOCK), mGuidList);\r
+  if (mGuidList == NULL) {\r
+    mGuidListCount = 0;\r

     return (EFI_OUT_OF_RESOURCES);\r
   }\r
     return (EFI_OUT_OF_RESOURCES);\r
   }\r

-  GuidListCount++;\r
+  mGuidListCount++;\r

 \r
 \r

-  GuidList[GuidListCount - 1].GuidId   = AllocateCopyPool(sizeof(EFI_GUID), Guid);\r
-  GuidList[GuidListCount - 1].StringId = NameID;\r
-  GuidList[GuidListCount - 1].DumpInfo = DumpFunc;\r
+  mGuidList[mGuidListCount - 1].GuidId   = AllocateCopyPool(sizeof(EFI_GUID), Guid);\r
+  mGuidList[mGuidListCount - 1].StringId = NameID;\r
+  mGuidList[mGuidListCount - 1].DumpInfo = DumpFunc;\r

 \r
 \r

-  if (GuidList[GuidListCount - 1].GuidId == NULL) {\r
+  if (mGuidList[mGuidListCount - 1].GuidId == NULL) {\r

     return (EFI_OUT_OF_RESOURCES);\r
   }\r
 \r
     return (EFI_OUT_OF_RESOURCES);\r
   }\r
 \r


@@ -1189,7 +2548,10 @@ GetStringNameFromGuid(
   HandleParsingHiiInit();\r
 \r
   Id = InternalShellGetNodeFromGuid(Guid);\r
   HandleParsingHiiInit();\r
 \r
   Id = InternalShellGetNodeFromGuid(Guid);\r

-  return (HiiGetString(mHandleParsingHiiHandle, Id==NULL?STRING_TOKEN(STR_UNKNOWN_DEVICE):Id->StringId, Lang));\r
+  if (Id == NULL) {\r
+    return NULL;\r
+  }\r
+  return HiiGetString (mHandleParsingHiiHandle, Id->StringId, Lang);\r

 }\r
 \r
 /**\r
 }\r
 \r
 /**\r


@@ -1286,7 +2648,7 @@ GetGuidFromStringName(
     }\r
   }\r
 \r
     }\r
   }\r
 \r

-  for (LoopCount = 0, ListWalker = GuidList; GuidList != NULL && LoopCount < GuidListCount; LoopCount++, ListWalker++) {\r
+  for (LoopCount = 0, ListWalker = mGuidList; mGuidList != NULL && LoopCount < mGuidListCount; LoopCount++, ListWalker++) {\r

     String = HiiGetString(mHandleParsingHiiHandle, ListWalker->StringId, Lang);\r
     if (Name != NULL && String != NULL && StringNoCaseCompare (&Name, &String) == 0) {\r
       *Guid = ListWalker->GuidId;\r
     String = HiiGetString(mHandleParsingHiiHandle, ListWalker->StringId, Lang);\r
     if (Name != NULL && String != NULL && StringNoCaseCompare (&Name, &String) == 0) {\r
       *Guid = ListWalker->GuidId;\r


@@ -1411,7 +2773,6 @@ GetStringNameFromHandle(
   @retval EFI_SUCCESS     The operation was successful.\r
 **/\r
 EFI_STATUS\r
   @retval EFI_SUCCESS     The operation was successful.\r
 **/\r
 EFI_STATUS\r

-EFIAPI\r

 InternalShellInitHandleList(\r
   VOID\r
   )\r
 InternalShellInitHandleList(\r
   VOID\r
   )\r


@@ -1439,10 +2800,11 @@ InternalShellInitHandleList(
   }\r
   for (mHandleList.NextIndex = 1 ; mHandleList.NextIndex <= HandleCount ; mHandleList.NextIndex++){\r
     ListWalker = AllocateZeroPool(sizeof(HANDLE_LIST));\r
   }\r
   for (mHandleList.NextIndex = 1 ; mHandleList.NextIndex <= HandleCount ; mHandleList.NextIndex++){\r
     ListWalker = AllocateZeroPool(sizeof(HANDLE_LIST));\r

-    ASSERT(ListWalker != NULL);\r
-    ListWalker->TheHandle = HandleBuffer[mHandleList.NextIndex-1];\r
-    ListWalker->TheIndex  = mHandleList.NextIndex;\r
-    InsertTailList(&mHandleList.List.Link,&ListWalker->Link);\r
+    if (ListWalker != NULL) {\r
+      ListWalker->TheHandle = HandleBuffer[mHandleList.NextIndex - 1];\r
+      ListWalker->TheIndex = mHandleList.NextIndex;\r
+      InsertTailList (&mHandleList.List.Link, &ListWalker->Link);\r
+    }\r

   }\r
   FreePool(HandleBuffer);\r
   return (EFI_SUCCESS);\r
   }\r
   FreePool(HandleBuffer);\r
   return (EFI_SUCCESS);\r


@@ -1510,7 +2872,9 @@ ConvertHandleToHandleIndex(
   FreePool (ProtocolBuffer);\r
 \r
   ListWalker = AllocateZeroPool(sizeof(HANDLE_LIST));\r
   FreePool (ProtocolBuffer);\r
 \r
   ListWalker = AllocateZeroPool(sizeof(HANDLE_LIST));\r

-  ASSERT(ListWalker != NULL);\r
+  if (ListWalker == NULL) {\r
+    return 0;\r
+  }\r

   ListWalker->TheHandle = TheHandle;\r
   ListWalker->TheIndex  = mHandleList.NextIndex++;\r
   InsertTailList(&mHandleList.List.Link,&ListWalker->Link);\r
   ListWalker->TheHandle = TheHandle;\r
   ListWalker->TheIndex  = mHandleList.NextIndex++;\r
   InsertTailList(&mHandleList.List.Link,&ListWalker->Link);\r


@@ -1554,7 +2918,9 @@ ConvertHandleIndexToHandle(
       // Verify that LinkWalker->TheHandle is valid handle\r
       //\r
       Status = gBS->ProtocolsPerHandle(ListWalker->TheHandle, &ProtocolBuffer, &ProtocolCount);\r
       // Verify that LinkWalker->TheHandle is valid handle\r
       //\r
       Status = gBS->ProtocolsPerHandle(ListWalker->TheHandle, &ProtocolBuffer, &ProtocolCount);\r

-      if (EFI_ERROR (Status)) {\r
+      if (!EFI_ERROR (Status)) {\r
+        FreePool (ProtocolBuffer);\r
+      } else {\r

         //\r
         // TheHandle is not valid, so do not add to handle list\r
         //\r
         //\r
         // TheHandle is not valid, so do not add to handle list\r
         //\r


@@ -1637,7 +3003,11 @@ ParseHandleDatabaseByRelationshipWithType (
   }\r
 \r
   *HandleType = AllocateZeroPool (*HandleCount * sizeof (UINTN));\r
   }\r
 \r
   *HandleType = AllocateZeroPool (*HandleCount * sizeof (UINTN));\r

-  ASSERT(*HandleType != NULL);\r
+  if (*HandleType == NULL) {\r
+    SHELL_FREE_NON_NULL (*HandleBuffer);\r
+    *HandleCount = 0;\r
+    return EFI_OUT_OF_RESOURCES;\r
+  }\r

 \r
   DriverBindingHandleIndex = -1;\r
   for (HandleIndex = 0; HandleIndex < *HandleCount; HandleIndex++) {\r
 \r
   DriverBindingHandleIndex = -1;\r
   for (HandleIndex = 0; HandleIndex < *HandleCount; HandleIndex++) {\r


@@ -1682,10 +3052,6 @@ ParseHandleDatabaseByRelationshipWithType (
         (*HandleType)[HandleIndex] |= (UINTN)HR_COMPONENT_NAME_HANDLE;\r
       } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDevicePathProtocolGuid)          ) {\r
         (*HandleType)[HandleIndex] |= (UINTN)HR_DEVICE_HANDLE;\r
         (*HandleType)[HandleIndex] |= (UINTN)HR_COMPONENT_NAME_HANDLE;\r
       } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDevicePathProtocolGuid)          ) {\r
         (*HandleType)[HandleIndex] |= (UINTN)HR_DEVICE_HANDLE;\r

-      } else {\r
-        DEBUG_CODE_BEGIN();\r
-        ASSERT((*HandleType)[HandleIndex] == (*HandleType)[HandleIndex]);\r
-        DEBUG_CODE_END();\r

       }\r
       //\r
       // Retrieve the list of agents that have opened each protocol\r
       }\r
       //\r
       // Retrieve the list of agents that have opened each protocol\r


@@ -1897,26 +3263,28 @@ ParseHandleDatabaseByRelationship (
         // Allocate a handle buffer for the number of handles that matched the attributes in Mask\r
         //\r
         *MatchingHandleBuffer = AllocateZeroPool ((*MatchingHandleCount +1)* sizeof (EFI_HANDLE));\r
         // Allocate a handle buffer for the number of handles that matched the attributes in Mask\r
         //\r
         *MatchingHandleBuffer = AllocateZeroPool ((*MatchingHandleCount +1)* sizeof (EFI_HANDLE));\r

-        ASSERT(*MatchingHandleBuffer != NULL);\r
+        if (*MatchingHandleBuffer == NULL) {\r
+          Status = EFI_OUT_OF_RESOURCES;\r
+        } else {\r
+          for (HandleIndex = 0, *MatchingHandleCount = 0\r
+               ;  HandleIndex < HandleCount\r
+               ;  HandleIndex++\r
+               ) {\r
+            //\r
+            // Fill the allocated buffer with the handles that matched the attributes in Mask\r
+            //\r
+            if ((HandleType[HandleIndex] & Mask) == Mask) {\r
+              (*MatchingHandleBuffer)[(*MatchingHandleCount)++] = HandleBuffer[HandleIndex];\r
+            }\r
+          }\r

 \r
 \r

-        for (HandleIndex = 0,*MatchingHandleCount = 0\r
-          ;  HandleIndex < HandleCount\r
-          ;  HandleIndex++\r
-         ){\r

           //\r
           //\r

-          // Fill the allocated buffer with the handles that matched the attributes in Mask\r
+          // Make the last one NULL\r

           //\r
           //\r

-          if ((HandleType[HandleIndex] & Mask) == Mask) {\r
-            (*MatchingHandleBuffer)[(*MatchingHandleCount)++] = HandleBuffer[HandleIndex];\r
-          }\r
-        }\r
-\r
-        //\r
-        // Make the last one NULL\r
-        //\r
-        (*MatchingHandleBuffer)[*MatchingHandleCount] = NULL;\r
+          (*MatchingHandleBuffer)[*MatchingHandleCount] = NULL;\r

 \r
 \r

-        Status = EFI_SUCCESS;\r
+          Status = EFI_SUCCESS;\r
+        } // *MatchingHandleBuffer == NULL (ELSE)\r

       } // MacthingHandleBuffer == NULL (ELSE)\r
     } // *MatchingHandleCount  == 0 (ELSE)\r
   } // no error on ParseHandleDatabaseByRelationshipWithType\r
       } // MacthingHandleBuffer == NULL (ELSE)\r
     } // *MatchingHandleCount  == 0 (ELSE)\r
   } // no error on ParseHandleDatabaseByRelationshipWithType\r


@@ -1929,6 +3297,9 @@ ParseHandleDatabaseByRelationship (
     FreePool (HandleType);\r
   }\r
 \r
     FreePool (HandleType);\r
   }\r
 \r

+  ASSERT ((MatchingHandleBuffer == NULL) ||\r
+          (*MatchingHandleCount == 0 && *MatchingHandleBuffer == NULL) ||\r
+          (*MatchingHandleCount != 0 && *MatchingHandleBuffer != NULL));\r

   return Status;\r
 }\r
 \r
   return Status;\r
 }\r
 \r


@@ -1936,7 +3307,7 @@ ParseHandleDatabaseByRelationship (
   Gets handles for any child controllers of the passed in controller.\r
 \r
   @param[in] ControllerHandle       The handle of the "parent controller"\r
   Gets handles for any child controllers of the passed in controller.\r
 \r
   @param[in] ControllerHandle       The handle of the "parent controller"\r

-  @param[in] MatchingHandleCount    Pointer to the number of handles in\r
+  @param[out] MatchingHandleCount   Pointer to the number of handles in\r

                                     MatchingHandleBuffer on return.\r
   @param[out] MatchingHandleBuffer  Buffer containing handles on a successful\r
                                     return.\r
                                     MatchingHandleBuffer on return.\r
   @param[out] MatchingHandleBuffer  Buffer containing handles on a successful\r
                                     return.\r


@@ -1948,7 +3319,7 @@ EFI_STATUS
 EFIAPI\r
 ParseHandleDatabaseForChildControllers(\r
   IN CONST EFI_HANDLE       ControllerHandle,\r
 EFIAPI\r
 ParseHandleDatabaseForChildControllers(\r
   IN CONST EFI_HANDLE       ControllerHandle,\r

-  IN UINTN                  *MatchingHandleCount,\r
+  OUT UINTN                 *MatchingHandleCount,\r

   OUT EFI_HANDLE            **MatchingHandleBuffer OPTIONAL\r
   )\r
 {\r
   OUT EFI_HANDLE            **MatchingHandleBuffer OPTIONAL\r
   )\r
 {\r


@@ -2015,12 +3386,22 @@ ParseHandleDatabaseForChildControllers(
 \r
   FreePool (DriverBindingHandleBuffer);\r
 \r
 \r
   FreePool (DriverBindingHandleBuffer);\r
 \r

+  if (MatchingHandleBuffer == NULL || *MatchingHandleCount == 0) {\r
+    //\r
+    // The caller is not interested in the actual handles, or we've found none.\r
+    //\r
+    FreePool (HandleBufferForReturn);\r
+    HandleBufferForReturn = NULL;\r
+  }\r
+\r

   if (MatchingHandleBuffer != NULL) {\r
     *MatchingHandleBuffer = HandleBufferForReturn;\r
   if (MatchingHandleBuffer != NULL) {\r
     *MatchingHandleBuffer = HandleBufferForReturn;\r

-  } else {\r
-    FreePool(HandleBufferForReturn);\r

   }\r
 \r
   }\r
 \r

+  ASSERT ((MatchingHandleBuffer == NULL) ||\r
+          (*MatchingHandleCount == 0 && *MatchingHandleBuffer == NULL) ||\r
+          (*MatchingHandleCount != 0 && *MatchingHandleBuffer != NULL));\r
+\r

   return (EFI_SUCCESS);\r
 }\r
 \r
   return (EFI_SUCCESS);\r
 }\r
 \r


@@ -2040,7 +3421,6 @@ ParseHandleDatabaseForChildControllers(
   @return                           A pointer to (*DestinationBuffer).\r
 **/\r
 VOID*\r
   @return                           A pointer to (*DestinationBuffer).\r
 **/\r
 VOID*\r

-EFIAPI\r

 BuffernCatGrow (\r
   IN OUT VOID   **DestinationBuffer,\r
   IN OUT UINTN  *DestinationSize,\r
 BuffernCatGrow (\r
   IN OUT VOID   **DestinationBuffer,\r
   IN OUT UINTN  *DestinationSize,\r


@@ -2250,7 +3630,7 @@ GetHandleListByProtocolList (
   }\r
 \r
   //\r
   }\r
 \r
   //\r

-  // No handles were found... \r
+  // No handles were found...\r

   //\r
   if (TotalSize == sizeof(EFI_HANDLE)) {\r
     return (NULL);\r
   //\r
   if (TotalSize == sizeof(EFI_HANDLE)) {\r
     return (NULL);\r


@@ -2289,12 +3669,54 @@ GetHandleListByProtocolList (
   return (HandleList);\r
 }\r
 \r
   return (HandleList);\r
 }\r
 \r

+/**\r
+  Return all supported GUIDs.\r

 \r
 \r

+  @param[out]     Guids  The buffer to return all supported GUIDs.\r
+  @param[in, out] Count  On input, the count of GUIDs the buffer can hold,\r
+                         On output, the count of GUIDs to return.\r

 \r
 \r

+  @retval EFI_INVALID_PARAMETER Count is NULL.\r
+  @retval EFI_BUFFER_TOO_SMALL  Buffer is not enough to hold all GUIDs.\r
+  @retval EFI_SUCCESS           GUIDs are returned successfully.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+GetAllMappingGuids (\r
+  OUT EFI_GUID *Guids,\r
+  IN OUT UINTN *Count\r
+  )\r
+{\r
+  UINTN GuidCount;\r
+  UINTN NtGuidCount;\r
+  UINTN Index;\r

 \r
 \r

+  if (Count == NULL) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r

 \r
 \r

+  NtGuidCount = 0;\r
+  if (PcdGetBool (PcdShellIncludeNtGuids)) {\r
+    NtGuidCount = ARRAY_SIZE (mGuidStringListNT) - 1;\r
+  }\r
+  GuidCount   = ARRAY_SIZE (mGuidStringList) - 1;\r

 \r
 \r

+  if (*Count < NtGuidCount + GuidCount + mGuidListCount) {\r
+    *Count = NtGuidCount + GuidCount + mGuidListCount;\r
+    return EFI_BUFFER_TOO_SMALL;\r
+  }\r

 \r
 \r

+  for (Index = 0; Index < NtGuidCount; Index++) {\r
+    CopyGuid (&Guids[Index], mGuidStringListNT[Index].GuidId);\r
+  }\r

 \r
 \r

+  for (Index = 0; Index < GuidCount; Index++) {\r
+    CopyGuid (&Guids[NtGuidCount + Index], mGuidStringList[Index].GuidId);\r
+  }\r

 \r
 \r

+  for (Index = 0; Index < mGuidListCount; Index++) {\r
+    CopyGuid (&Guids[NtGuidCount + GuidCount + Index], mGuidList[Index].GuidId);\r
+  }\r

 \r
 \r

+  return EFI_SUCCESS;\r
+}\r