[mirror_edk2.git] / ShellPkg / Library / UefiShellDriver1CommandsLib / Dh.c

/** @file\r
  Main file for Dh shell Driver1 function.\r
\r
  (C) Copyright 2014-2015 Hewlett-Packard Development Company, L.P.<BR>\r
  Copyright (c) 2010 - 2018, Intel Corporation. All rights reserved.<BR>\r
  (C) Copyright 2017 Hewlett Packard Enterprise Development LP<BR>\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "UefiShellDriver1CommandsLib.h"\r
\r
STATIC CONST SHELL_PARAM_ITEM  ParamList[] = {\r
  { L"-p",       TypeValue },\r
  { L"-d",       TypeFlag  },\r
  { L"-v",       TypeFlag  },\r
  { L"-verbose", TypeFlag  },\r
  { L"-sfo",     TypeFlag  },\r
  { L"-l",       TypeValue },\r
  { NULL,        TypeMax   }\r
};\r
\r
STATIC CONST EFI_GUID  *UefiDriverModelProtocolsGuidArray[] = {\r
  &gEfiDriverBindingProtocolGuid,\r
  &gEfiPlatformDriverOverrideProtocolGuid,\r
  &gEfiBusSpecificDriverOverrideProtocolGuid,\r
  &gEfiDriverDiagnosticsProtocolGuid,\r
  &gEfiDriverDiagnostics2ProtocolGuid,\r
  &gEfiComponentNameProtocolGuid,\r
  &gEfiComponentName2ProtocolGuid,\r
  &gEfiPlatformToDriverConfigurationProtocolGuid,\r
  &gEfiDriverSupportedEfiVersionProtocolGuid,\r
  &gEfiDriverFamilyOverrideProtocolGuid,\r
  &gEfiDriverHealthProtocolGuid,\r
  &gEfiLoadedImageProtocolGuid,\r
  NULL\r
};\r
\r
UINTN  mGuidDataLen[] = { 8, 4, 4, 4, 12 };\r
\r
/**\r
  Function to determine if the string can convert to a GUID.\r
  The string must be restricted as "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" format.\r
\r
  @param[in]  String  The string to test.\r
\r
  @retval     TRUE    The string can convert to a GUID.\r
  @retval     FALSE   The string can't convert to a GUID.\r
**/\r
BOOLEAN\r
IsValidGuidString (\r
  IN CONST CHAR16  *String\r
  )\r
{\r
  CONST CHAR16  *Walker;\r
  CONST CHAR16  *PrevWalker;\r
  UINTN         Index;\r
\r
  if (String == NULL) {\r
    return FALSE;\r
  }\r
\r
  Walker     = String;\r
  PrevWalker = String;\r
  Index      = 0;\r
\r
  while (Walker != NULL && *Walker != CHAR_NULL) {\r
    if (((*Walker >= '0') && (*Walker <= '9')) ||\r
        ((*Walker >= 'a') && (*Walker <= 'f')) ||\r
        ((*Walker >= 'A') && (*Walker <= 'F'))\r
        )\r
    {\r
      Walker++;\r
    } else {\r
      if ((*Walker == L'-') && ((((UINTN)Walker - (UINTN)PrevWalker) / sizeof (CHAR16)) == mGuidDataLen[Index])) {\r
        Walker++;\r
        PrevWalker = Walker;\r
        Index++;\r
      } else {\r
        return FALSE;\r
      }\r
    }\r
  }\r
\r
  if ((((UINTN)Walker - (UINTN)PrevWalker) / sizeof (CHAR16)) == mGuidDataLen[Index]) {\r
    return TRUE;\r
  } else {\r
    return FALSE;\r
  }\r
}\r
\r
/**\r
  Convert a hex-character to decimal value.\r
\r
  This internal function only deal with Unicode character\r
  which maps to a valid hexadecimal ASII character, i.e.\r
  L'0' to L'9', L'a' to L'f' or L'A' to L'F'. For other\r
  Unicode character, the value returned does not make sense.\r
\r
  @param[in]  Char      The character to convert.\r
\r
  @retval               The numerical value converted.\r
**/\r
UINTN\r
HexCharToDecimal (\r
  IN CHAR16  Char\r
  )\r
{\r
  if ((Char >= '0') && (Char <= '9')) {\r
    return Char - L'0';\r
  } else if ((Char >= 'a') && (Char <= 'f')) {\r
    return Char - L'a' + 10;\r
  } else {\r
    return Char - L'A' + 10;\r
  }\r
}\r
\r
/**\r
  Function try to convert a string to GUID format.\r
\r
  @param[in]    String    The string will be converted.\r
  @param[out]   Guid      Save the result convert from string.\r
\r
  @retval EFI_SUCCESS     The string was successfully converted to a GUID.\r
  @retval EFI_UNSUPPORTED The input string is not in registry format.\r
**/\r
EFI_STATUS\r
ConvertStrToGuid (\r
  IN  CONST CHAR16  *String,\r
  OUT GUID          *Guid\r
  )\r
{\r
  CONST CHAR16  *Walker;\r
  UINT8         TempValue;\r
  UINTN         Index;\r
\r
  if ((String == NULL) || !IsValidGuidString (String)) {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  Index = 0;\r
\r
  Walker      = String;\r
  Guid->Data1 = (UINT32)StrHexToUint64 (Walker);\r
\r
  Walker     += 9;\r
  Guid->Data2 = (UINT16)StrHexToUint64 (Walker);\r
\r
  Walker     += 5;\r
  Guid->Data3 = (UINT16)StrHexToUint64 (Walker);\r
\r
  Walker += 5;\r
  while (Walker != NULL && *Walker != CHAR_NULL) {\r
    if (*Walker == L'-') {\r
      Walker++;\r
    } else {\r
      TempValue = (UINT8)HexCharToDecimal (*Walker);\r
      TempValue = (UINT8)LShiftU64 (TempValue, 4);\r
      Walker++;\r
\r
      TempValue += (UINT8)HexCharToDecimal (*Walker);\r
      Walker++;\r
\r
      Guid->Data4[Index] = TempValue;\r
      Index++;\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Get the name of a driver by it's handle.\r
\r
  If a name is found the memory must be callee freed.\r
\r
  @param[in] TheHandle    The driver's handle.\r
  @param[in] Language     The language to use.\r
  @param[in] NameFound    Upon a successful return the name found.\r
\r
  @retval EFI_SUCCESS     The name was found.\r
**/\r
EFI_STATUS\r
GetDriverName (\r
  IN EFI_HANDLE   TheHandle,\r
  IN CONST CHAR8  *Language,\r
  IN CHAR16       **NameFound\r
  )\r
{\r
  CHAR8                         *Lang;\r
  EFI_STATUS                    Status;\r
  EFI_COMPONENT_NAME2_PROTOCOL  *CompName2;\r
  CHAR16                        *NameToReturn;\r
\r
  //\r
  // Go through those handles until we get one that passes for GetComponentName\r
  //\r
  Status = gBS->OpenProtocol (\r
                  TheHandle,\r
                  &gEfiComponentName2ProtocolGuid,\r
                  (VOID **)&CompName2,\r
                  gImageHandle,\r
                  NULL,\r
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    Status = gBS->OpenProtocol (\r
                    TheHandle,\r
                    &gEfiComponentNameProtocolGuid,\r
                    (VOID **)&CompName2,\r
                    gImageHandle,\r
                    NULL,\r
                    EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
                    );\r
  }\r
\r
  if (EFI_ERROR (Status)) {\r
    return (EFI_NOT_FOUND);\r
  }\r
\r
  Lang   = GetBestLanguageForDriver (CompName2->SupportedLanguages, Language, FALSE);\r
  Status = CompName2->GetDriverName (CompName2, Lang, &NameToReturn);\r
  FreePool (Lang);\r
\r
  if (!EFI_ERROR (Status) && (NameToReturn != NULL)) {\r
    *NameFound = NULL;\r
    StrnCatGrow (NameFound, NULL, NameToReturn, 0);\r
  }\r
\r
  return (Status);\r
}\r
\r
/**\r
  Discover if a protocol guid is one of the UEFI Driver Model Protocols.\r
\r
  @param[in] Guid   The guid to test.\r
\r
  @retval TRUE      The guid does represent a driver model protocol.\r
  @retval FALSE     The guid does not represent a driver model protocol.\r
**/\r
BOOLEAN\r
IsDriverProt (\r
  IN CONST EFI_GUID  *Guid\r
  )\r
{\r
  CONST EFI_GUID  **GuidWalker;\r
  BOOLEAN         GuidFound;\r
\r
  GuidFound = FALSE;\r
  for (GuidWalker = UefiDriverModelProtocolsGuidArray\r
       ; GuidWalker != NULL && *GuidWalker != NULL\r
       ; GuidWalker++\r
       )\r
  {\r
    if (CompareGuid (*GuidWalker, Guid)) {\r
      GuidFound = TRUE;\r
      break;\r
    }\r
  }\r
\r
  return (GuidFound);\r
}\r
\r
/**\r
  Get information for a handle.\r
\r
  @param[in] TheHandle        The handles to show info on.\r
  @param[in] Language         Language string per UEFI specification.\r
  @param[in] Separator        Separator string between information blocks.\r
  @param[in] Verbose          TRUE for extra info, FALSE otherwise.\r
  @param[in] ExtraInfo        TRUE for extra info, FALSE otherwise.\r
\r
  @retval SHELL_SUCCESS           The operation was successful.\r
  @retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.\r
**/\r
CHAR16 *\r
GetProtocolInfoString (\r
  IN CONST EFI_HANDLE  TheHandle,\r
  IN CONST CHAR8       *Language,\r
  IN CONST CHAR16      *Separator,\r
  IN CONST BOOLEAN     Verbose,\r
  IN CONST BOOLEAN     ExtraInfo\r
  )\r
{\r
  EFI_GUID    **ProtocolGuidArray;\r
  UINTN       ArrayCount;\r
  UINTN       ProtocolIndex;\r
  EFI_STATUS  Status;\r
  CHAR16      *RetVal;\r
  UINTN       Size;\r
  CHAR16      *Temp;\r
  CHAR16      GuidStr[40];\r
  VOID        *Instance;\r
  CHAR16      InstanceStr[17];\r
\r
  ProtocolGuidArray = NULL;\r
  RetVal            = NULL;\r
  Size              = 0;\r
\r
  Status = gBS->ProtocolsPerHandle (\r
                  TheHandle,\r
                  &ProtocolGuidArray,\r
                  &ArrayCount\r
                  );\r
  if (!EFI_ERROR (Status)) {\r
    for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++) {\r
      Temp = GetStringNameFromGuid (ProtocolGuidArray[ProtocolIndex], Language);\r
      ASSERT ((RetVal == NULL && Size == 0) || (RetVal != NULL));\r
      if (Size != 0) {\r
        StrnCatGrow (&RetVal, &Size, Separator, 0);\r
      }\r
\r
      StrnCatGrow (&RetVal, &Size, L"%H", 0);\r
      if (Temp == NULL) {\r
        UnicodeSPrint (GuidStr, sizeof (GuidStr), L"%g", ProtocolGuidArray[ProtocolIndex]);\r
        StrnCatGrow (&RetVal, &Size, GuidStr, 0);\r
      } else {\r
        StrnCatGrow (&RetVal, &Size, Temp, 0);\r
        FreePool (Temp);\r
      }\r
\r
      StrnCatGrow (&RetVal, &Size, L"%N", 0);\r
\r
      if (Verbose) {\r
        Status = gBS->HandleProtocol (TheHandle, ProtocolGuidArray[ProtocolIndex], &Instance);\r
        if (!EFI_ERROR (Status)) {\r
          StrnCatGrow (&RetVal, &Size, L"(%H", 0);\r
          UnicodeSPrint (InstanceStr, sizeof (InstanceStr), L"%x", Instance);\r
          StrnCatGrow (&RetVal, &Size, InstanceStr, 0);\r
          StrnCatGrow (&RetVal, &Size, L"%N)", 0);\r
        }\r
      }\r
\r
      if (ExtraInfo) {\r
        Temp = GetProtocolInformationDump (TheHandle, ProtocolGuidArray[ProtocolIndex], Verbose);\r
        if (Temp != NULL) {\r
          ASSERT ((RetVal == NULL && Size == 0) || (RetVal != NULL));\r
          if (!Verbose) {\r
            StrnCatGrow (&RetVal, &Size, L"(", 0);\r
            StrnCatGrow (&RetVal, &Size, Temp, 0);\r
            StrnCatGrow (&RetVal, &Size, L")", 0);\r
          } else {\r
            StrnCatGrow (&RetVal, &Size, Separator, 0);\r
            StrnCatGrow (&RetVal, &Size, Temp, 0);\r
          }\r
\r
          FreePool (Temp);\r
        }\r
      }\r
    }\r
  }\r
\r
  SHELL_FREE_NON_NULL (ProtocolGuidArray);\r
\r
  if (RetVal == NULL) {\r
    return (NULL);\r
  }\r
\r
  ASSERT ((RetVal == NULL && Size == 0) || (RetVal != NULL));\r
  StrnCatGrow (&RetVal, &Size, Separator, 0);\r
  return (RetVal);\r
}\r
\r
/**\r
  Gets the name of the loaded image.\r
\r
  @param[in] TheHandle    The handle of the driver to get info on.\r
  @param[out] Name        The pointer to the pointer.  Valid upon a successful return.\r
\r
  @retval EFI_SUCCESS     The operation was successful.\r
**/\r
EFI_STATUS\r
GetDriverImageName (\r
  IN EFI_HANDLE  TheHandle,\r
  OUT CHAR16     **Name\r
  )\r
{\r
  // get loaded image and devicepathtotext on image->Filepath\r
  EFI_LOADED_IMAGE_PROTOCOL  *LoadedImage;\r
  EFI_STATUS                 Status;\r
  EFI_DEVICE_PATH_PROTOCOL   *DevicePath;\r
\r
  if ((TheHandle == NULL) || (Name == NULL)) {\r
    return (EFI_INVALID_PARAMETER);\r
  }\r
\r
  Status = gBS->OpenProtocol (\r
                  TheHandle,\r
                  &gEfiLoadedImageProtocolGuid,\r
                  (VOID **)&LoadedImage,\r
                  gImageHandle,\r
                  NULL,\r
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return (Status);\r
  }\r
\r
  DevicePath = LoadedImage->FilePath;\r
  *Name      = ConvertDevicePathToText (DevicePath, TRUE, TRUE);\r
  return (EFI_SUCCESS);\r
}\r
\r
/**\r
  Display driver model information for a given handle.\r
\r
  @param[in] Handle     The handle to display info on.\r
  @param[in] BestName   Use the best name?\r
  @param[in] Language   The language to output in.\r
**/\r
EFI_STATUS\r
DisplayDriverModelHandle (\r
  IN EFI_HANDLE   Handle,\r
  IN BOOLEAN      BestName,\r
  IN CONST CHAR8  *Language OPTIONAL\r
  )\r
{\r
  EFI_STATUS                   Status;\r
  BOOLEAN                      ConfigurationStatus;\r
  BOOLEAN                      DiagnosticsStatus;\r
  UINTN                        DriverBindingHandleCount;\r
  EFI_HANDLE                   *DriverBindingHandleBuffer;\r
  UINTN                        ParentControllerHandleCount;\r
  EFI_HANDLE                   *ParentControllerHandleBuffer;\r
  UINTN                        ChildControllerHandleCount;\r
  EFI_HANDLE                   *ChildControllerHandleBuffer;\r
  CHAR16                       *TempStringPointer;\r
  EFI_DEVICE_PATH_PROTOCOL     *DevicePath;\r
  UINTN                        Index;\r
  CHAR16                       *DriverName;\r
  EFI_DRIVER_BINDING_PROTOCOL  *DriverBinding;\r
  UINTN                        NumberOfChildren;\r
  UINTN                        HandleIndex;\r
  UINTN                        ControllerHandleCount;\r
  EFI_HANDLE                   *ControllerHandleBuffer;\r
  UINTN                        ChildIndex;\r
  BOOLEAN                      Image;\r
\r
  DriverName = NULL;\r
\r
  //\r
  // See if Handle is a device handle and display its details.\r
  //\r
  DriverBindingHandleBuffer = NULL;\r
  Status                    = PARSE_HANDLE_DATABASE_UEFI_DRIVERS (\r
                                Handle,\r
                                &DriverBindingHandleCount,\r
                                &DriverBindingHandleBuffer\r
                                );\r
\r
  ParentControllerHandleBuffer = NULL;\r
  Status                       = PARSE_HANDLE_DATABASE_PARENTS (\r
                                   Handle,\r
                                   &ParentControllerHandleCount,\r
                                   &ParentControllerHandleBuffer\r
                                   );\r
\r
  ChildControllerHandleBuffer = NULL;\r
  Status                      = ParseHandleDatabaseForChildControllers (\r
                                  Handle,\r
                                  &ChildControllerHandleCount,\r
                                  &ChildControllerHandleBuffer\r
                                  );\r
\r
  DiagnosticsStatus   = FALSE;\r
  ConfigurationStatus = FALSE;\r
\r
  if (!EFI_ERROR (gBS->OpenProtocol (Handle, &gEfiDriverConfigurationProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {\r
    ConfigurationStatus = TRUE;\r
  }\r
\r
  if (!EFI_ERROR (gBS->OpenProtocol (Handle, &gEfiDriverConfiguration2ProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {\r
    ConfigurationStatus = TRUE;\r
  }\r
\r
  if (!EFI_ERROR (gBS->OpenProtocol (Handle, &gEfiDriverDiagnosticsProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {\r
    DiagnosticsStatus = TRUE;\r
  }\r
\r
  if (!EFI_ERROR (gBS->OpenProtocol (Handle, &gEfiDriverDiagnostics2ProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {\r
    DiagnosticsStatus = TRUE;\r
  }\r
\r
  Status = EFI_SUCCESS;\r
\r
  if ((DriverBindingHandleCount > 0) || (ParentControllerHandleCount > 0) || (ChildControllerHandleCount > 0)) {\r
    DevicePath        = NULL;\r
    TempStringPointer = NULL;\r
    Status            = gBS->HandleProtocol (Handle, &gEfiDevicePathProtocolGuid, (VOID **)&DevicePath);\r
\r
    Status = gEfiShellProtocol->GetDeviceName (Handle, EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8 *)Language, &TempStringPointer);\r
    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_DRIVER1), gShellDriver1HiiHandle, TempStringPointer != NULL ? TempStringPointer : L"<Unknown>");\r
    SHELL_FREE_NON_NULL (TempStringPointer);\r
\r
    TempStringPointer = ConvertDevicePathToText (DevicePath, TRUE, FALSE);\r
    ShellPrintHiiEx (\r
      -1,\r
      -1,\r
      NULL,\r
      STRING_TOKEN (STR_DH_OUTPUT_DRIVER2),\r
      gShellDriver1HiiHandle,\r
      TempStringPointer != NULL ? TempStringPointer : L"<None>",\r
      ParentControllerHandleCount == 0 ? L"ROOT" : (ChildControllerHandleCount > 0) ? L"BUS" : L"DEVICE",\r
      ConfigurationStatus ? L"YES" : L"NO",\r
      DiagnosticsStatus ? L"YES" : L"NO"\r
      );\r
\r
    SHELL_FREE_NON_NULL (TempStringPointer);\r
\r
    if (DriverBindingHandleCount == 0) {\r
      ShellPrintHiiEx (\r
        -1,\r
        -1,\r
        NULL,\r
        STRING_TOKEN (STR_DH_OUTPUT_DRIVER3),\r
        gShellDriver1HiiHandle,\r
        L"<None>"\r
        );\r
    } else {\r
      ShellPrintHiiEx (\r
        -1,\r
        -1,\r
        NULL,\r
        STRING_TOKEN (STR_DH_OUTPUT_DRIVER3),\r
        gShellDriver1HiiHandle,\r
        L""\r
        );\r
      for (Index = 0; Index < DriverBindingHandleCount; Index++) {\r
        Image  = FALSE;\r
        Status = GetDriverName (\r
                   DriverBindingHandleBuffer[Index],\r
                   Language,\r
                   &DriverName\r
                   );\r
        if (EFI_ERROR (Status)) {\r
          Status = GetDriverImageName (\r
                     DriverBindingHandleBuffer[Index],\r
                     &DriverName\r
                     );\r
          if (EFI_ERROR (Status)) {\r
            DriverName = NULL;\r
          }\r
        }\r
\r
        if (Image) {\r
          ShellPrintHiiEx (\r
            -1,\r
            -1,\r
            NULL,\r
            STRING_TOKEN (STR_DH_OUTPUT_DRIVER4A),\r
            gShellDriver1HiiHandle,\r
            ConvertHandleToHandleIndex (DriverBindingHandleBuffer[Index]),\r
            DriverName != NULL ? DriverName : L"<Unknown>"\r
            );\r
        } else {\r
          ShellPrintHiiEx (\r
            -1,\r
            -1,\r
            NULL,\r
            STRING_TOKEN (STR_DH_OUTPUT_DRIVER4B),\r
            gShellDriver1HiiHandle,\r
            ConvertHandleToHandleIndex (DriverBindingHandleBuffer[Index]),\r
            DriverName != NULL ? DriverName : L"<Unknown>"\r
            );\r
        }\r
\r
        SHELL_FREE_NON_NULL (DriverName);\r
      }\r
    }\r
\r
    if (ParentControllerHandleCount == 0) {\r
      ShellPrintHiiEx (\r
        -1,\r
        -1,\r
        NULL,\r
        STRING_TOKEN (STR_DH_OUTPUT_DRIVER5),\r
        gShellDriver1HiiHandle,\r
        L"<None>"\r
        );\r
    } else {\r
      ShellPrintHiiEx (\r
        -1,\r
        -1,\r
        NULL,\r
        STRING_TOKEN (STR_DH_OUTPUT_DRIVER5),\r
        gShellDriver1HiiHandle,\r
        L""\r
        );\r
      for (Index = 0; Index < ParentControllerHandleCount; Index++) {\r
        Status = gEfiShellProtocol->GetDeviceName (ParentControllerHandleBuffer[Index], EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8 *)Language, &TempStringPointer);\r
        ShellPrintHiiEx (\r
          -1,\r
          -1,\r
          NULL,\r
          STRING_TOKEN (STR_DH_OUTPUT_DRIVER5B),\r
          gShellDriver1HiiHandle,\r
          ConvertHandleToHandleIndex (ParentControllerHandleBuffer[Index]),\r
          TempStringPointer != NULL ? TempStringPointer : L"<Unknown>"\r
          );\r
        SHELL_FREE_NON_NULL (TempStringPointer);\r
      }\r
    }\r
\r
    if (ChildControllerHandleCount == 0) {\r
      ShellPrintHiiEx (\r
        -1,\r
        -1,\r
        NULL,\r
        STRING_TOKEN (STR_DH_OUTPUT_DRIVER6),\r
        gShellDriver1HiiHandle,\r
        L"<None>"\r
        );\r
    } else {\r
      ShellPrintHiiEx (\r
        -1,\r
        -1,\r
        NULL,\r
        STRING_TOKEN (STR_DH_OUTPUT_DRIVER6),\r
        gShellDriver1HiiHandle,\r
        L""\r
        );\r
      for (Index = 0; Index < ChildControllerHandleCount; Index++) {\r
        Status = gEfiShellProtocol->GetDeviceName (ChildControllerHandleBuffer[Index], EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8 *)Language, &TempStringPointer);\r
        ShellPrintHiiEx (\r
          -1,\r
          -1,\r
          NULL,\r
          STRING_TOKEN (STR_DH_OUTPUT_DRIVER6B),\r
          gShellDriver1HiiHandle,\r
          ConvertHandleToHandleIndex (ChildControllerHandleBuffer[Index]),\r
          TempStringPointer != NULL ? TempStringPointer : L"<Unknown>"\r
          );\r
        SHELL_FREE_NON_NULL (TempStringPointer);\r
      }\r
    }\r
  }\r
\r
  SHELL_FREE_NON_NULL (DriverBindingHandleBuffer);\r
\r
  SHELL_FREE_NON_NULL (ParentControllerHandleBuffer);\r
\r
  SHELL_FREE_NON_NULL (ChildControllerHandleBuffer);\r
\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // See if Handle is a driver binding handle and display its details.\r
  //\r
  Status = gBS->OpenProtocol (\r
                  Handle,\r
                  &gEfiDriverBindingProtocolGuid,\r
                  (VOID **)&DriverBinding,\r
                  NULL,\r
                  NULL,\r
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  NumberOfChildren       = 0;\r
  ControllerHandleBuffer = NULL;\r
  Status                 = PARSE_HANDLE_DATABASE_DEVICES (\r
                             Handle,\r
                             &ControllerHandleCount,\r
                             &ControllerHandleBuffer\r
                             );\r
  if (ControllerHandleCount > 0) {\r
    for (HandleIndex = 0; HandleIndex < ControllerHandleCount; HandleIndex++) {\r
      Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (\r
                 Handle,\r
                 ControllerHandleBuffer[HandleIndex],\r
                 &ChildControllerHandleCount,\r
                 NULL\r
                 );\r
      NumberOfChildren += ChildControllerHandleCount;\r
    }\r
  }\r
\r
  Status = GetDriverName (Handle, Language, &DriverName);\r
  if (EFI_ERROR (Status)) {\r
    DriverName = NULL;\r
  }\r
\r
  ShellPrintHiiEx (\r
    -1,\r
    -1,\r
    NULL,\r
    STRING_TOKEN (STR_DH_OUTPUT_DRIVER7),\r
    gShellDriver1HiiHandle,\r
    ConvertHandleToHandleIndex (Handle),\r
    DriverName != NULL ? DriverName : L"<Unknown>"\r
    );\r
  SHELL_FREE_NON_NULL (DriverName);\r
  Status = GetDriverImageName (\r
             Handle,\r
             &DriverName\r
             );\r
  if (EFI_ERROR (Status)) {\r
    DriverName = NULL;\r
  }\r
\r
  ShellPrintHiiEx (\r
    -1,\r
    -1,\r
    NULL,\r
    STRING_TOKEN (STR_DH_OUTPUT_DRIVER7B),\r
    gShellDriver1HiiHandle,\r
    DriverName != NULL ? DriverName : L"<Unknown>"\r
    );\r
  SHELL_FREE_NON_NULL (DriverName);\r
\r
  ShellPrintHiiEx (\r
    -1,\r
    -1,\r
    NULL,\r
    STRING_TOKEN (STR_DH_OUTPUT_DRIVER8),\r
    gShellDriver1HiiHandle,\r
    DriverBinding->Version,\r
    NumberOfChildren > 0 ? L"Bus" : ControllerHandleCount > 0 ? L"Device" : L"<Unknown>",\r
    ConfigurationStatus ? L"YES" : L"NO",\r
    DiagnosticsStatus ? L"YES" : L"NO"\r
    );\r
\r
  if (ControllerHandleCount == 0) {\r
    ShellPrintHiiEx (\r
      -1,\r
      -1,\r
      NULL,\r
      STRING_TOKEN (STR_DH_OUTPUT_DRIVER9),\r
      gShellDriver1HiiHandle,\r
      L"None"\r
      );\r
  } else {\r
    ShellPrintHiiEx (\r
      -1,\r
      -1,\r
      NULL,\r
      STRING_TOKEN (STR_DH_OUTPUT_DRIVER9),\r
      gShellDriver1HiiHandle,\r
      L""\r
      );\r
    for (HandleIndex = 0; HandleIndex < ControllerHandleCount; HandleIndex++) {\r
      Status = gEfiShellProtocol->GetDeviceName (ControllerHandleBuffer[HandleIndex], EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8 *)Language, &TempStringPointer);\r
\r
      ShellPrintHiiEx (\r
        -1,\r
        -1,\r
        NULL,\r
        STRING_TOKEN (STR_DH_OUTPUT_DRIVER9B),\r
        gShellDriver1HiiHandle,\r
        ConvertHandleToHandleIndex (ControllerHandleBuffer[HandleIndex]),\r
        TempStringPointer != NULL ? TempStringPointer : L"<Unknown>"\r
        );\r
      SHELL_FREE_NON_NULL (TempStringPointer);\r
\r
      Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (\r
                 Handle,\r
                 ControllerHandleBuffer[HandleIndex],\r
                 &ChildControllerHandleCount,\r
                 &ChildControllerHandleBuffer\r
                 );\r
      if (!EFI_ERROR (Status)) {\r
        for (ChildIndex = 0; ChildIndex < ChildControllerHandleCount; ChildIndex++) {\r
          Status = gEfiShellProtocol->GetDeviceName (ChildControllerHandleBuffer[ChildIndex], EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8 *)Language, &TempStringPointer);\r
\r
          ShellPrintHiiEx (\r
            -1,\r
            -1,\r
            NULL,\r
            STRING_TOKEN (STR_DH_OUTPUT_DRIVER6C),\r
            gShellDriver1HiiHandle,\r
            ConvertHandleToHandleIndex (ChildControllerHandleBuffer[ChildIndex]),\r
            TempStringPointer != NULL ? TempStringPointer : L"<Unknown>"\r
            );\r
          SHELL_FREE_NON_NULL (TempStringPointer);\r
        }\r
\r
        SHELL_FREE_NON_NULL (ChildControllerHandleBuffer);\r
      }\r
    }\r
\r
    SHELL_FREE_NON_NULL (ControllerHandleBuffer);\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Display information for a handle.\r
\r
  @param[in] TheHandle        The handles to show info on.\r
  @param[in] Verbose          TRUE for extra info, FALSE otherwise.\r
  @param[in] Sfo              TRUE to output in standard format output (spec).\r
  @param[in] Language         Language string per UEFI specification.\r
  @param[in] DriverInfo       TRUE to show all info about the handle.\r
  @param[in] Multiple         TRUE indicates more than  will be output,\r
                              FALSE for a single one.\r
**/\r
VOID\r
DoDhByHandle (\r
  IN CONST EFI_HANDLE  TheHandle,\r
  IN CONST BOOLEAN     Verbose,\r
  IN CONST BOOLEAN     Sfo,\r
  IN CONST CHAR8       *Language,\r
  IN CONST BOOLEAN     DriverInfo,\r
  IN CONST BOOLEAN     Multiple\r
  )\r
{\r
  CHAR16  *ProtocolInfoString;\r
\r
  ProtocolInfoString = NULL;\r
\r
  if (!Sfo) {\r
    if (Multiple) {\r
      ProtocolInfoString = GetProtocolInfoString (TheHandle, Language, L" ", Verbose, TRUE);\r
      ShellPrintHiiEx (\r
        -1,\r
        -1,\r
        NULL,\r
        STRING_TOKEN (STR_DH_OUTPUT),\r
        gShellDriver1HiiHandle,\r
        ConvertHandleToHandleIndex (TheHandle),\r
        ProtocolInfoString == NULL ? L"" : ProtocolInfoString\r
        );\r
    } else {\r
      ProtocolInfoString = GetProtocolInfoString (TheHandle, Language, Verbose ? L"\r\n" : L" ", Verbose, TRUE);\r
      if (Verbose) {\r
        ShellPrintHiiEx (\r
          -1,\r
          -1,\r
          NULL,\r
          STRING_TOKEN (STR_DH_OUTPUT_SINGLE),\r
          gShellDriver1HiiHandle,\r
          ConvertHandleToHandleIndex (TheHandle),\r
          TheHandle,\r
          ProtocolInfoString == NULL ? L"" : ProtocolInfoString\r
          );\r
      } else {\r
        ShellPrintHiiEx (\r
          -1,\r
          -1,\r
          NULL,\r
          STRING_TOKEN (STR_DH_OUTPUT_SINGLE_D),\r
          gShellDriver1HiiHandle,\r
          ConvertHandleToHandleIndex (TheHandle),\r
          ProtocolInfoString == NULL ? L"" : ProtocolInfoString\r
          );\r
      }\r
    }\r
\r
    if (DriverInfo) {\r
      DisplayDriverModelHandle ((EFI_HANDLE)TheHandle, TRUE, Language);\r
    }\r
  } else {\r
    ProtocolInfoString = GetProtocolInfoString (TheHandle, Language, L";", FALSE, FALSE);\r
    ShellPrintHiiEx (\r
      -1,\r
      -1,\r
      NULL,\r
      STRING_TOKEN (STR_DH_OUTPUT_SFO),\r
      gShellDriver1HiiHandle,\r
      Multiple ? L"HandlesInfo" : L"HandleInfo",\r
      L"DriverName",\r
      L"ControllerName",\r
      ConvertHandleToHandleIndex (TheHandle),\r
      L"DevPath",\r
      ProtocolInfoString == NULL ? L"" : ProtocolInfoString\r
      );\r
  }\r
\r
  if (ProtocolInfoString != NULL) {\r
    FreePool (ProtocolInfoString);\r
  }\r
}\r
\r
/**\r
  Display information for all handles on a list.\r
\r
  @param[in] HandleList       The NULL-terminated list of handles.\r
  @param[in] Verbose          TRUE for extra info, FALSE otherwise.\r
  @param[in] Sfo              TRUE to output in standard format output (spec).\r
  @param[in] Language         Language string per UEFI specification.\r
  @param[in] DriverInfo       TRUE to show all info about the handle.\r
\r
  @retval SHELL_SUCCESS       The operation was successful.\r
  @retval SHELL_ABORTED       The operation was aborted.\r
**/\r
SHELL_STATUS\r
DoDhForHandleList (\r
  IN CONST EFI_HANDLE  *HandleList,\r
  IN CONST BOOLEAN     Verbose,\r
  IN CONST BOOLEAN     Sfo,\r
  IN CONST CHAR8       *Language,\r
  IN CONST BOOLEAN     DriverInfo\r
  )\r
{\r
  CONST EFI_HANDLE  *HandleWalker;\r
  SHELL_STATUS      ShellStatus;\r
\r
  ShellStatus = SHELL_SUCCESS;\r
  for (HandleWalker = HandleList; HandleWalker != NULL && *HandleWalker != NULL; HandleWalker++) {\r
    DoDhByHandle (*HandleWalker, Verbose, Sfo, Language, DriverInfo, TRUE);\r
    if (ShellGetExecutionBreakFlag ()) {\r
      ShellStatus = SHELL_ABORTED;\r
      break;\r
    }\r
  }\r
\r
  return (ShellStatus);\r
}\r
\r
/**\r
  Display information for a GUID of protocol.\r
\r
  @param[in] Guid             The pointer to the name of the protocol.\r
  @param[in] Verbose          TRUE for extra info, FALSE otherwise.\r
  @param[in] Sfo              TRUE to output in standard format output (spec).\r
  @param[in] Language         Language string per UEFI specification.\r
  @param[in] DriverInfo       TRUE to show all info about the handle.\r
\r
  @retval SHELL_SUCCESS           The operation was successful.\r
  @retval SHELL_NOT_FOUND         The GUID was not found.\r
  @retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.\r
**/\r
SHELL_STATUS\r
DoDhByProtocolGuid (\r
  IN CONST GUID     *Guid,\r
  IN CONST BOOLEAN  Verbose,\r
  IN CONST BOOLEAN  Sfo,\r
  IN CONST CHAR8    *Language,\r
  IN CONST BOOLEAN  DriverInfo\r
  )\r
{\r
  CHAR16        *Name;\r
  SHELL_STATUS  ShellStatus;\r
  EFI_HANDLE    *HandleList;\r
\r
  if (!Sfo) {\r
    if (Guid == NULL) {\r
      ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_ALL_HEADER), gShellDriver1HiiHandle);\r
    } else {\r
      Name = GetStringNameFromGuid (Guid, NULL);\r
      if (Name == NULL) {\r
        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_GUID_HEADER), gShellDriver1HiiHandle, Guid);\r
      } else {\r
        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_NAME_HEADER), gShellDriver1HiiHandle, Name);\r
      }\r
    }\r
  }\r
\r
  HandleList  = GetHandleListByProtocol (Guid);\r
  ShellStatus = DoDhForHandleList (HandleList, Verbose, Sfo, Language, DriverInfo);\r
  SHELL_FREE_NON_NULL (HandleList);\r
\r
  return ShellStatus;\r
}\r
\r
/**\r
  Function to determine use which method to print information.\r
  If Protocol is NULL, The function will print all information.\r
\r
  @param[in] Protocol         The pointer to the name or GUID of protocol or NULL.\r
  @param[in] Verbose          TRUE for extra info, FALSE otherwise.\r
  @param[in] Sfo              TRUE to output in standard format output (spec).\r
  @param[in] Language         Language string per UEFI specification.\r
  @param[in] DriverInfo       TRUE to show all info about the handle.\r
\r
  @retval SHELL_SUCCESS             The operation was successful.\r
  @retval SHELL_NOT_FOUND           The protocol was not found.\r
  @retval SHELL_INVALID_PARAMETER   Protocol is invalid parameter.\r
**/\r
SHELL_STATUS\r
DoDhByProtocol (\r
  IN CONST CHAR16   *Protocol,\r
  IN CONST BOOLEAN  Verbose,\r
  IN CONST BOOLEAN  Sfo,\r
  IN CONST CHAR8    *Language,\r
  IN CONST BOOLEAN  DriverInfo\r
  )\r
{\r
  EFI_GUID    Guid;\r
  EFI_GUID    *GuidPtr;\r
  EFI_STATUS  Status;\r
\r
  if (Protocol == NULL) {\r
    return DoDhByProtocolGuid (NULL, Verbose, Sfo, Language, DriverInfo);\r
  } else {\r
    Status = ConvertStrToGuid (Protocol, &Guid);\r
    if (!EFI_ERROR (Status)) {\r
      GuidPtr = &Guid;\r
    } else {\r
      //\r
      // Protocol is a Name, convert it to GUID\r
      //\r
      Status = GetGuidFromStringName (Protocol, Language, &GuidPtr);\r
      if (EFI_ERROR (Status)) {\r
        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_NO_NAME_FOUND), gShellDriver1HiiHandle, Protocol);\r
        return (SHELL_NOT_FOUND);\r
      }\r
    }\r
\r
    return DoDhByProtocolGuid (GuidPtr, Verbose, Sfo, Language, DriverInfo);\r
  }\r
}\r
\r
/**\r
  Function to display decode information by Protocol.\r
  The parameter Protocol is either a GUID or the name of protocol.\r
  If the parameter Protocol is NULL, the function will print all\r
  decode information.\r
\r
  @param[in] Protocol         The pointer to the name or GUID of protocol.\r
  @param[in] Language         Language string per UEFI specification.\r
\r
  @retval SHELL_SUCCESS           The operation was successful.\r
  @retval SHELL_OUT_OT_RESOURCES  A memory allocation failed.\r
**/\r
SHELL_STATUS\r
DoDecodeByProtocol (\r
  IN CONST CHAR16  *Protocol,\r
  IN CONST CHAR8   *Language\r
  )\r
{\r
  EFI_STATUS  Status;\r
  EFI_GUID    *Guids;\r
  EFI_GUID    Guid;\r
  UINTN       Counts;\r
  UINTN       Index;\r
  CHAR16      *Name;\r
\r
  if (Protocol == NULL) {\r
    Counts = 0;\r
    Status = GetAllMappingGuids (NULL, &Counts);\r
    if (Status == EFI_BUFFER_TOO_SMALL) {\r
      Guids = AllocatePool (Counts * sizeof (EFI_GUID));\r
      if (Guids == NULL) {\r
        return SHELL_OUT_OF_RESOURCES;\r
      }\r
\r
      Status = GetAllMappingGuids (Guids, &Counts);\r
      if (Status == EFI_SUCCESS) {\r
        for (Index = 0; Index < Counts; Index++) {\r
          Name = GetStringNameFromGuid (&Guids[Index], Language);\r
          if (Name != NULL) {\r
            ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_DECODE), gShellDriver1HiiHandle, Name, &Guids[Index]);\r
          } else {\r
            ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_NO_GUID_FOUND), gShellDriver1HiiHandle, &Guids[Index]);\r
          }\r
\r
          SHELL_FREE_NON_NULL (Name);\r
        }\r
      }\r
\r
      FreePool (Guids);\r
    }\r
  } else {\r
    if (ConvertStrToGuid (Protocol, &Guid) == EFI_SUCCESS) {\r
      Name = GetStringNameFromGuid (&Guid, Language);\r
      if (Name != NULL) {\r
        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_DECODE), gShellDriver1HiiHandle, Name, &Guid);\r
      } else {\r
        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_NO_GUID_FOUND), gShellDriver1HiiHandle, &Guid);\r
      }\r
\r
      SHELL_FREE_NON_NULL (Name);\r
    } else {\r
      Status = GetGuidFromStringName (Protocol, Language, &Guids);\r
      if (Status == EFI_SUCCESS) {\r
        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_DECODE), gShellDriver1HiiHandle, Protocol, Guids);\r
      } else {\r
        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_NO_NAME_FOUND), gShellDriver1HiiHandle, Protocol);\r
      }\r
    }\r
  }\r
\r
  return SHELL_SUCCESS;\r
}\r
\r
/**\r
  Function for 'dh' command.\r
\r
  @param[in] ImageHandle  Handle to the Image (NULL if Internal).\r
  @param[in] SystemTable  Pointer to the System Table (NULL if Internal).\r
**/\r
SHELL_STATUS\r
EFIAPI\r
ShellCommandRunDh (\r
  IN EFI_HANDLE        ImageHandle,\r
  IN EFI_SYSTEM_TABLE  *SystemTable\r
  )\r
{\r
  EFI_STATUS    Status;\r
  LIST_ENTRY    *Package;\r
  CHAR16        *ProblemParam;\r
  SHELL_STATUS  ShellStatus;\r
  CHAR8         *Language;\r
  CONST CHAR16  *Lang;\r
  CONST CHAR16  *RawValue;\r
  CONST CHAR16  *ProtocolVal;\r
  BOOLEAN       SfoFlag;\r
  BOOLEAN       DriverFlag;\r
  BOOLEAN       VerboseFlag;\r
  UINT64        Intermediate;\r
  EFI_HANDLE    Handle;\r
\r
  ShellStatus = SHELL_SUCCESS;\r
  Status      = EFI_SUCCESS;\r
  Language    = NULL;\r
\r
  //\r
  // initialize the shell lib (we must be in non-auto-init...)\r
  //\r
  Status = ShellInitialize ();\r
  ASSERT_EFI_ERROR (Status);\r
\r
  Status = CommandInit ();\r
  ASSERT_EFI_ERROR (Status);\r
\r
  //\r
  // parse the command line\r
  //\r
  Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);\r
  if (EFI_ERROR (Status)) {\r
    if ((Status == EFI_VOLUME_CORRUPTED) && (ProblemParam != NULL)) {\r
      ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDriver1HiiHandle, L"dh", ProblemParam);\r
      FreePool (ProblemParam);\r
      ShellStatus = SHELL_INVALID_PARAMETER;\r
    } else {\r
      ASSERT (FALSE);\r
    }\r
  } else {\r
    if (ShellCommandLineGetCount (Package) > 2) {\r
      ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle, L"dh");\r
      ShellCommandLineFreeVarList (Package);\r
      return (SHELL_INVALID_PARAMETER);\r
    }\r
\r
    if (ShellCommandLineGetFlag (Package, L"-l")) {\r
      Lang = ShellCommandLineGetValue (Package, L"-l");\r
      if (Lang != NULL) {\r
        Language = AllocateZeroPool (StrSize (Lang));\r
        AsciiSPrint (Language, StrSize (Lang), "%S", Lang);\r
      } else {\r
        ASSERT (Language == NULL);\r
        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"dh", L"-l");\r
        ShellCommandLineFreeVarList (Package);\r
        return (SHELL_INVALID_PARAMETER);\r
      }\r
    } else {\r
      Language = AllocateZeroPool (10);\r
      AsciiSPrint (Language, 10, "en-us");\r
    }\r
\r
    SfoFlag     = ShellCommandLineGetFlag (Package, L"-sfo");\r
    DriverFlag  = ShellCommandLineGetFlag (Package, L"-d");\r
    VerboseFlag = (BOOLEAN)(ShellCommandLineGetFlag (Package, L"-v") || ShellCommandLineGetFlag (Package, L"-verbose"));\r
    RawValue    = ShellCommandLineGetRawValue (Package, 1);\r
    ProtocolVal = ShellCommandLineGetValue (Package, L"-p");\r
\r
    if (RawValue == NULL) {\r
      if (ShellCommandLineGetFlag (Package, L"-p") && (ProtocolVal == NULL)) {\r
        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"dh", L"-p");\r
        ShellStatus = SHELL_INVALID_PARAMETER;\r
      } else {\r
        //\r
        // Print information by protocol, The ProtocolVal maybe is name or GUID or NULL.\r
        //\r
        ShellStatus = DoDhByProtocol (ProtocolVal, VerboseFlag, SfoFlag, Language, DriverFlag);\r
      }\r
    } else if ((RawValue != NULL) &&\r
               (gUnicodeCollation->StriColl (gUnicodeCollation, L"decode", (CHAR16 *)RawValue) == 0))\r
    {\r
      if (ShellCommandLineGetFlag (Package, L"-p") && (ProtocolVal == NULL)) {\r
        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"dh", L"-p");\r
        ShellStatus = SHELL_INVALID_PARAMETER;\r
      } else {\r
        //\r
        // Print decode informatino by protocol.\r
        //\r
        ShellStatus = DoDecodeByProtocol (ProtocolVal, Language);\r
      }\r
    } else {\r
      if (ShellCommandLineGetFlag (Package, L"-p")) {\r
        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle, L"dh");\r
        ShellStatus = SHELL_INVALID_PARAMETER;\r
      } else {\r
        Status = ShellConvertStringToUint64 (RawValue, &Intermediate, TRUE, FALSE);\r
        if (EFI_ERROR (Status)) {\r
          ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, L"dh", RawValue);\r
          ShellStatus = SHELL_INVALID_PARAMETER;\r
        } else {\r
          Handle = ConvertHandleIndexToHandle ((UINTN)Intermediate);\r
          if (Handle == NULL) {\r
            ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, L"dh", RawValue);\r
            ShellStatus = SHELL_INVALID_PARAMETER;\r
          } else {\r
            //\r
            // Print information by handle.\r
            //\r
            DoDhByHandle (Handle, VerboseFlag, SfoFlag, Language, DriverFlag, FALSE);\r
          }\r
        }\r
      }\r
    }\r
\r
    ShellCommandLineFreeVarList (Package);\r
    SHELL_FREE_NON_NULL (Language);\r
  }\r
\r
  return (ShellStatus);\r
}\r