ShellPkg/Library/UefiShellDriver1CommandsLib/Dh.c

   1 /** @file
   2   Main file for Dh shell Driver1 function.
   3
   4   Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>
   5   This program and the accompanying materials
   6   are licensed and made available under the terms and conditions of the BSD License
   7   which accompanies this distribution.  The full text of the license may be found at
   8   http://opensource.org/licenses/bsd-license.php
   9
  10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "UefiShellDriver1CommandsLib.h"
  16
  17 STATIC CONST SHELL_PARAM_ITEM ParamList[] = {
  18   {L"-p", TypeValue},
  19   {L"-d", TypeFlag},
  20   {L"-v", TypeFlag},
  21   {L"-verbose", TypeFlag},
  22   {L"-sfo", TypeFlag},
  23   {L"-l", TypeValue},
  24   {NULL, TypeMax}
  25   };
  26
  27 STATIC CONST EFI_GUID *UefiDriverModelProtocolsGuidArray[] = {
  28   &gEfiDriverBindingProtocolGuid,
  29   &gEfiPlatformDriverOverrideProtocolGuid,
  30   &gEfiBusSpecificDriverOverrideProtocolGuid,
  31   &gEfiDriverDiagnosticsProtocolGuid,
  32   &gEfiDriverDiagnostics2ProtocolGuid,
  33   &gEfiComponentNameProtocolGuid,
  34   &gEfiComponentName2ProtocolGuid,
  35   &gEfiPlatformToDriverConfigurationProtocolGuid,
  36   &gEfiDriverSupportedEfiVersionProtocolGuid,
  37   &gEfiDriverFamilyOverrideProtocolGuid,
  38   &gEfiDriverHealthProtocolGuid,
  39   &gEfiLoadedImageProtocolGuid,
  40   NULL
  41 };
  42
  43 /**
  44   Get the name of a driver by it's handle.
  45
  46   If a name is found the memory must be callee freed.
  47
  48   @param[in] TheHandle    The driver's handle.
  49   @param[in] Language     The language to use.
  50   @param[in] NameFound    Upon a successful return the name found.
  51
  52   @retval EFI_SUCCESS     The name was found.
  53 **/
  54 EFI_STATUS
  55 EFIAPI
  56 GetDriverName (
  57   IN EFI_HANDLE   TheHandle,
  58   IN CONST CHAR8  *Language,
  59   IN CHAR16       **NameFound
  60   )
  61 {
  62   CHAR8                             *Lang;
  63   CHAR8                             *TempChar;
  64   EFI_STATUS                        Status;
  65   EFI_COMPONENT_NAME2_PROTOCOL      *CompName2;
  66   CHAR16                            *NameToReturn;
  67   //
  68   // Go through those handles until we get one that passes for GetComponentName
  69   //
  70   Status = gBS->OpenProtocol(
  71     TheHandle,
  72     &gEfiComponentName2ProtocolGuid,
  73     (VOID**)&CompName2,
  74     gImageHandle,
  75     NULL,
  76     EFI_OPEN_PROTOCOL_GET_PROTOCOL);
  77   if (EFI_ERROR(Status)) {
  78     Status = gBS->OpenProtocol(
  79       TheHandle,
  80       &gEfiComponentNameProtocolGuid,
  81       (VOID**)&CompName2,
  82       gImageHandle,
  83       NULL,
  84       EFI_OPEN_PROTOCOL_GET_PROTOCOL);
  85   }
  86
  87   if (EFI_ERROR(Status)) {
  88     return (EFI_NOT_FOUND);
  89   }
  90   if (Language == NULL) {
  91     Lang = AllocateZeroPool(AsciiStrSize(CompName2->SupportedLanguages));
  92     if (Lang == NULL) {
  93       return (EFI_OUT_OF_RESOURCES);
  94     }
  95     AsciiStrCpy(Lang, CompName2->SupportedLanguages);
  96     TempChar = AsciiStrStr(Lang, ";");
  97     if (TempChar != NULL){
  98       *TempChar = CHAR_NULL;
  99     }
 100   } else {
 101     Lang = AllocateZeroPool(AsciiStrSize(Language));
 102     if (Lang == NULL) {
 103       return (EFI_OUT_OF_RESOURCES);
 104     }
 105     AsciiStrCpy(Lang, Language);
 106   }
 107   Status = CompName2->GetDriverName(CompName2, Lang, &NameToReturn);
 108   FreePool(Lang);
 109
 110   if (!EFI_ERROR(Status) && NameToReturn != NULL) {
 111     *NameFound = NULL;
 112     StrnCatGrow(NameFound, NULL, NameToReturn, 0);
 113   }
 114   return (Status);
 115 }
 116
 117 /**
 118   Discover if a protocol guid is one of the UEFI Driver Model Protocols.
 119
 120   @param[in] Guid   The guid to test.
 121
 122   @retval TRUE      The guid does represent a driver model protocol.
 123   @retval FALSE     The guid does not represent a driver model protocol.
 124 **/
 125 BOOLEAN
 126 EFIAPI
 127 IsDriverProt (
 128   IN CONST EFI_GUID *Guid
 129   )
 130 {
 131   CONST EFI_GUID            **GuidWalker;
 132   BOOLEAN                   GuidFound;
 133   GuidFound = FALSE;
 134   for (GuidWalker = UefiDriverModelProtocolsGuidArray
 135     ;  GuidWalker != NULL && *GuidWalker != NULL
 136     ;  GuidWalker++
 137    ){
 138     if (CompareGuid(*GuidWalker, Guid)) {
 139       GuidFound = TRUE;
 140       break;
 141     }
 142   }
 143   return (GuidFound);
 144 }
 145
 146 /**
 147   Get information for a handle.
 148
 149   @param[in] TheHandle        The handles to show info on.
 150   @param[in] Language         Language string per UEFI specification.
 151   @param[in] Seperator        Separator string between information blocks.
 152   @param[in] Verbose          TRUE for extra info, FALSE otherwise.
 153   @param[in] ExtraInfo        TRUE for extra info, FALSE otherwise.
 154
 155   @retval SHELL_SUCCESS           The operation was successful.
 156   @retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
 157 **/
 158 CHAR16*
 159 EFIAPI
 160 GetProtocolInfoString(
 161   IN CONST EFI_HANDLE TheHandle,
 162   IN CONST CHAR8      *Language,
 163   IN CONST CHAR16     *Seperator,
 164   IN CONST BOOLEAN    Verbose,
 165   IN CONST BOOLEAN    ExtraInfo
 166   )
 167 {
 168   EFI_GUID                  **ProtocolGuidArray;
 169   UINTN                     ArrayCount;
 170   UINTN                     ProtocolIndex;
 171   EFI_STATUS                Status;
 172   CHAR16                    *RetVal;
 173   UINTN                     Size;
 174   CHAR16                    *Temp;
 175
 176   ProtocolGuidArray = NULL;
 177   RetVal            = NULL;
 178   Size              = 0;
 179
 180   Status = gBS->ProtocolsPerHandle (
 181                 TheHandle,
 182                 &ProtocolGuidArray,
 183                 &ArrayCount
 184                );
 185   if (!EFI_ERROR (Status)) {
 186     for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++) {
 187       Temp = GetStringNameFromGuid(ProtocolGuidArray[ProtocolIndex], Language);
 188       if (Temp != NULL) {
 189         ASSERT((RetVal == NULL && Size == 0) || (RetVal != NULL));
 190         if (Size != 0) {
 191           StrnCatGrow(&RetVal, &Size, Seperator, 0);
 192         }
 193         StrnCatGrow(&RetVal, &Size, L"%H", 0);
 194         StrnCatGrow(&RetVal, &Size, Temp, 0);
 195         StrnCatGrow(&RetVal, &Size, L"%N", 0);
 196         FreePool(Temp);
 197       }
 198       if (ExtraInfo) {
 199         Temp = GetProtocolInformationDump(TheHandle, ProtocolGuidArray[ProtocolIndex], Verbose);
 200         if (Temp != NULL) {
 201           ASSERT((RetVal == NULL && Size == 0) || (RetVal != NULL));
 202           if (!Verbose) {
 203             StrnCatGrow(&RetVal, &Size, L"(", 0);
 204             StrnCatGrow(&RetVal, &Size, Temp, 0);
 205             StrnCatGrow(&RetVal, &Size, L")\r\n", 0);
 206           } else {
 207             StrnCatGrow(&RetVal, &Size, Seperator, 0);
 208             StrnCatGrow(&RetVal, &Size, Temp, 0);
 209           }
 210           FreePool(Temp);
 211         }
 212       }
 213     }
 214   }
 215
 216   SHELL_FREE_NON_NULL(ProtocolGuidArray);
 217
 218   if (RetVal == NULL) {
 219     return (NULL);
 220   }
 221
 222   ASSERT((RetVal == NULL && Size == 0) || (RetVal != NULL));
 223   StrnCatGrow(&RetVal, &Size, Seperator, 0);
 224   return (RetVal);
 225 }
 226
 227 /**
 228   Gets the name of the loaded image.
 229
 230   @param[in] TheHandle    The handle of the driver to get info on.
 231   @param[out] Name        The pointer to the pointer.  Valid upon a successful return.
 232
 233   @retval EFI_SUCCESS     The operation was successful.
 234 **/
 235 EFI_STATUS
 236 EFIAPI
 237 GetDriverImageName (
 238   IN EFI_HANDLE   TheHandle,
 239   OUT CHAR16      **Name
 240   )
 241 {
 242   // get loaded image and devicepathtotext on image->Filepath
 243   EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
 244   EFI_STATUS                Status;
 245   EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
 246
 247   if (TheHandle == NULL || Name == NULL) {
 248     return (EFI_INVALID_PARAMETER);
 249   }
 250
 251   Status = gBS->OpenProtocol (
 252                 TheHandle,
 253                 &gEfiLoadedImageProtocolGuid,
 254                 (VOID **) &LoadedImage,
 255                 gImageHandle,
 256                 NULL,
 257                 EFI_OPEN_PROTOCOL_GET_PROTOCOL
 258                );
 259   if (EFI_ERROR(Status)) {
 260     return (Status);
 261   }
 262   DevicePath = LoadedImage->FilePath;
 263   *Name = gDevPathToText->ConvertDevicePathToText(DevicePath, TRUE, TRUE);
 264   return (EFI_SUCCESS);
 265 }
 266
 267 /**
 268   Display driver model information for a given handle.
 269
 270   @param[in] Handle     The handle to display info on.
 271   @param[in] BestName   Use the best name?
 272   @param[in] Language   The language to output in.
 273 **/
 274 EFI_STATUS
 275 EFIAPI
 276 DisplayDriverModelHandle (
 277   IN EFI_HANDLE  Handle,
 278   IN BOOLEAN     BestName,
 279   IN CONST CHAR8 *Language OPTIONAL
 280   )
 281 {
 282   EFI_STATUS                  Status;
 283   BOOLEAN                     ConfigurationStatus;
 284   BOOLEAN                     DiagnosticsStatus;
 285   UINTN                       DriverBindingHandleCount;
 286   EFI_HANDLE                  *DriverBindingHandleBuffer;
 287   UINTN                       ParentControllerHandleCount;
 288   EFI_HANDLE                  *ParentControllerHandleBuffer;
 289   UINTN                       ChildControllerHandleCount;
 290   EFI_HANDLE                  *ChildControllerHandleBuffer;
 291   CHAR16                      *TempStringPointer;
 292   EFI_DEVICE_PATH_PROTOCOL    *DevicePath;
 293   UINTN                       Index;
 294   CHAR16                      *DriverName;
 295   EFI_DRIVER_BINDING_PROTOCOL *DriverBinding;
 296   UINTN                       NumberOfChildren;
 297   UINTN                       HandleIndex;
 298   UINTN                       ControllerHandleCount;
 299   EFI_HANDLE                  *ControllerHandleBuffer;
 300   UINTN                       ChildIndex;
 301   BOOLEAN                     Image;
 302
 303   //
 304   // See if Handle is a device handle and display its details.
 305   //
 306   DriverBindingHandleBuffer = NULL;
 307   Status = PARSE_HANDLE_DATABASE_UEFI_DRIVERS (
 308             Handle,
 309             &DriverBindingHandleCount,
 310             &DriverBindingHandleBuffer
 311             );
 312
 313   ParentControllerHandleBuffer = NULL;
 314   Status = PARSE_HANDLE_DATABASE_PARENTS (
 315             Handle,
 316             &ParentControllerHandleCount,
 317             &ParentControllerHandleBuffer
 318             );
 319
 320   ChildControllerHandleBuffer = NULL;
 321   Status = ParseHandleDatabaseForChildControllers (
 322             Handle,
 323             &ChildControllerHandleCount,
 324             &ChildControllerHandleBuffer
 325             );
 326
 327   DiagnosticsStatus = FALSE;
 328   ConfigurationStatus = FALSE;
 329
 330   if (!EFI_ERROR(gBS->OpenProtocol(Handle, &gEfiDriverConfigurationProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
 331     ConfigurationStatus = TRUE;
 332   }
 333   if (!EFI_ERROR(gBS->OpenProtocol(Handle, &gEfiDriverConfiguration2ProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
 334     ConfigurationStatus = TRUE;
 335   }
 336   if (!EFI_ERROR(gBS->OpenProtocol(Handle, &gEfiDriverDiagnosticsProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
 337     DiagnosticsStatus = TRUE;
 338   }
 339   if (!EFI_ERROR(gBS->OpenProtocol(Handle, &gEfiDriverDiagnostics2ProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
 340     DiagnosticsStatus = TRUE;
 341   }
 342
 343   Status = EFI_SUCCESS;
 344
 345   if (DriverBindingHandleCount > 0 || ParentControllerHandleCount > 0 || ChildControllerHandleCount > 0) {
 346
 347
 348
 349     DevicePath          = NULL;
 350     TempStringPointer   = NULL;
 351     Status              = gBS->HandleProtocol (Handle, &gEfiDevicePathProtocolGuid, (VOID**)&DevicePath);
 352
 353     Status = gEfiShellProtocol->GetDeviceName(Handle, EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
 354     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_DRIVER1), gShellDriver1HiiHandle, TempStringPointer!=NULL?TempStringPointer:L"<Unknown>");
 355     SHELL_FREE_NON_NULL(TempStringPointer);
 356
 357     TempStringPointer = gDevPathToText->ConvertDevicePathToText(DevicePath, TRUE, FALSE);
 358     ShellPrintHiiEx(
 359       -1,
 360       -1,
 361       NULL,
 362       STRING_TOKEN (STR_DH_OUTPUT_DRIVER2),
 363       gShellDriver1HiiHandle,
 364       TempStringPointer!=NULL?TempStringPointer:L"<None>",
 365       ParentControllerHandleCount == 0?L"ROOT":(ChildControllerHandleCount > 0)?L"BUS":L"DEVICE",
 366       ConfigurationStatus?L"YES":L"NO",
 367       DiagnosticsStatus?L"YES":L"NO"
 368       );
 369
 370     SHELL_FREE_NON_NULL(TempStringPointer);
 371
 372     if (DriverBindingHandleCount == 0) {
 373       ShellPrintHiiEx(
 374         -1,
 375         -1,
 376         NULL,
 377         STRING_TOKEN (STR_DH_OUTPUT_DRIVER3),
 378         gShellDriver1HiiHandle,
 379         L"<None>"
 380         );
 381     } else {
 382       ShellPrintHiiEx(
 383         -1,
 384         -1,
 385         NULL,
 386         STRING_TOKEN (STR_DH_OUTPUT_DRIVER3),
 387         gShellDriver1HiiHandle,
 388         L""
 389         );
 390       for (Index = 0; Index < DriverBindingHandleCount; Index++) {
 391         Image = FALSE;
 392         Status = GetDriverName (
 393                   DriverBindingHandleBuffer[Index],
 394                   Language,
 395                   &DriverName
 396                   );
 397         if (EFI_ERROR (Status)) {
 398           Status = GetDriverImageName (
 399                     DriverBindingHandleBuffer[Index],
 400                     &DriverName
 401                     );
 402           if (EFI_ERROR (Status)) {
 403             DriverName = NULL;
 404           }
 405         }
 406
 407         if (Image) {
 408           ShellPrintHiiEx(
 409             -1,
 410             -1,
 411             NULL,
 412             STRING_TOKEN (STR_DH_OUTPUT_DRIVER4A),
 413             gShellDriver1HiiHandle,
 414             ConvertHandleToHandleIndex (DriverBindingHandleBuffer[Index]),
 415             DriverName!=NULL?DriverName:L"<Unknown>"
 416             );
 417         } else {
 418           ShellPrintHiiEx(
 419             -1,
 420             -1,
 421             NULL,
 422             STRING_TOKEN (STR_DH_OUTPUT_DRIVER4B),
 423             gShellDriver1HiiHandle,
 424             ConvertHandleToHandleIndex (DriverBindingHandleBuffer[Index]),
 425             DriverName!=NULL?DriverName:L"<Unknown>"
 426             );
 427         }
 428         SHELL_FREE_NON_NULL(DriverName);
 429       }
 430     }
 431
 432     if (ParentControllerHandleCount == 0) {
 433       ShellPrintHiiEx(
 434         -1,
 435         -1,
 436         NULL,
 437         STRING_TOKEN (STR_DH_OUTPUT_DRIVER5),
 438         gShellDriver1HiiHandle,
 439         L"<None>"
 440         );
 441     } else {
 442       ShellPrintHiiEx(
 443         -1,
 444         -1,
 445         NULL,
 446         STRING_TOKEN (STR_DH_OUTPUT_DRIVER5),
 447         gShellDriver1HiiHandle,
 448         L""
 449         );
 450       for (Index = 0; Index < ParentControllerHandleCount; Index++) {
 451         Status = gEfiShellProtocol->GetDeviceName(ParentControllerHandleBuffer[Index], EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
 452         ShellPrintHiiEx(
 453           -1,
 454           -1,
 455           NULL,
 456           STRING_TOKEN (STR_DH_OUTPUT_DRIVER5B),
 457           gShellDriver1HiiHandle,
 458           ConvertHandleToHandleIndex (ParentControllerHandleBuffer[Index]),
 459           TempStringPointer!=NULL?TempStringPointer:L"<Unknown>"
 460           );
 461         SHELL_FREE_NON_NULL(TempStringPointer);
 462       }
 463     }
 464
 465     if (ChildControllerHandleCount == 0) {
 466       ShellPrintHiiEx(
 467         -1,
 468         -1,
 469         NULL,
 470         STRING_TOKEN (STR_DH_OUTPUT_DRIVER6),
 471         gShellDriver1HiiHandle,
 472         L"<None>"
 473         );
 474     } else {
 475       ShellPrintHiiEx(
 476         -1,
 477         -1,
 478         NULL,
 479         STRING_TOKEN (STR_DH_OUTPUT_DRIVER6),
 480         gShellDriver1HiiHandle,
 481         L""
 482         );
 483       for (Index = 0; Index < ChildControllerHandleCount; Index++) {
 484         Status = gEfiShellProtocol->GetDeviceName(ChildControllerHandleBuffer[Index], EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
 485         ShellPrintHiiEx(
 486           -1,
 487           -1,
 488           NULL,
 489           STRING_TOKEN (STR_DH_OUTPUT_DRIVER6B),
 490           gShellDriver1HiiHandle,
 491           ConvertHandleToHandleIndex (ChildControllerHandleBuffer[Index]),
 492           TempStringPointer!=NULL?TempStringPointer:L"<Unknown>"
 493           );
 494         SHELL_FREE_NON_NULL(TempStringPointer);
 495       }
 496     }
 497   }
 498
 499   SHELL_FREE_NON_NULL(DriverBindingHandleBuffer);
 500
 501   SHELL_FREE_NON_NULL(ParentControllerHandleBuffer);
 502
 503   SHELL_FREE_NON_NULL(ChildControllerHandleBuffer);
 504
 505   if (EFI_ERROR (Status)) {
 506     return Status;
 507   }
 508   //
 509   // See if Handle is a driver binding handle and display its details.
 510   //
 511   Status = gBS->OpenProtocol (
 512                 Handle,
 513                 &gEfiDriverBindingProtocolGuid,
 514                 (VOID **) &DriverBinding,
 515                 NULL,
 516                 NULL,
 517                 EFI_OPEN_PROTOCOL_GET_PROTOCOL
 518                 );
 519   if (EFI_ERROR (Status)) {
 520     return EFI_SUCCESS;
 521   }
 522
 523   NumberOfChildren        = 0;
 524   ControllerHandleBuffer  = NULL;
 525   Status = PARSE_HANDLE_DATABASE_DEVICES (
 526             Handle,
 527             &ControllerHandleCount,
 528             &ControllerHandleBuffer
 529             );
 530   if (ControllerHandleCount > 0) {
 531     for (HandleIndex = 0; HandleIndex < ControllerHandleCount; HandleIndex++) {
 532       Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
 533                 Handle,
 534                 ControllerHandleBuffer[HandleIndex],
 535                 &ChildControllerHandleCount,
 536                 NULL
 537                 );
 538       NumberOfChildren += ChildControllerHandleCount;
 539     }
 540   }
 541
 542   Status = GetDriverName (Handle, Language, &DriverName);
 543   if (EFI_ERROR (Status)) {
 544     DriverName = NULL;
 545   }
 546
 547   ShellPrintHiiEx(
 548     -1,
 549     -1,
 550     NULL,
 551     STRING_TOKEN (STR_DH_OUTPUT_DRIVER6B),
 552     gShellDriver1HiiHandle,
 553     ConvertHandleToHandleIndex(Handle),
 554     DriverName!=NULL?DriverName:L"<Unknown>"
 555     );
 556   SHELL_FREE_NON_NULL(DriverName);
 557   Status = GetDriverImageName (
 558             Handle,
 559             &DriverName
 560             );
 561   if (EFI_ERROR (Status)) {
 562     DriverName = NULL;
 563   }
 564   ShellPrintHiiEx(
 565     -1,
 566     -1,
 567     NULL,
 568     STRING_TOKEN (STR_DH_OUTPUT_DRIVER7B),
 569     gShellDriver1HiiHandle,
 570     DriverName!=NULL?DriverName:L"<Unknown>"
 571     );
 572   SHELL_FREE_NON_NULL(DriverName);
 573
 574   ShellPrintHiiEx(
 575     -1,
 576     -1,
 577     NULL,
 578     STRING_TOKEN (STR_DH_OUTPUT_DRIVER8),
 579     gShellDriver1HiiHandle,
 580     DriverBinding->Version,
 581     NumberOfChildren > 0?L"Bus":ControllerHandleCount > 0?L"Device":L"<Unknown>",
 582     ConfigurationStatus?L"YES":L"NO",
 583     DiagnosticsStatus?L"YES":L"NO"
 584     );
 585
 586   if (ControllerHandleCount == 0) {
 587       ShellPrintHiiEx(
 588         -1,
 589         -1,
 590         NULL,
 591         STRING_TOKEN (STR_DH_OUTPUT_DRIVER6),
 592         gShellDriver1HiiHandle,
 593         L"None"
 594         );
 595   } else {
 596     ShellPrintHiiEx(
 597       -1,
 598       -1,
 599       NULL,
 600       STRING_TOKEN (STR_DH_OUTPUT_DRIVER6),
 601       gShellDriver1HiiHandle,
 602       L""
 603       );
 604     for (HandleIndex = 0; HandleIndex < ControllerHandleCount; HandleIndex++) {
 605       Status = gEfiShellProtocol->GetDeviceName(ControllerHandleBuffer[HandleIndex], EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
 606
 607       ShellPrintHiiEx(
 608         -1,
 609         -1,
 610         NULL,
 611         STRING_TOKEN (STR_DH_OUTPUT_DRIVER9B),
 612         gShellDriver1HiiHandle,
 613         ConvertHandleToHandleIndex(ControllerHandleBuffer[HandleIndex]),
 614         TempStringPointer!=NULL?TempStringPointer:L"<Unknown>"
 615         );
 616       SHELL_FREE_NON_NULL(TempStringPointer);
 617
 618       Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
 619                 Handle,
 620                 ControllerHandleBuffer[HandleIndex],
 621                 &ChildControllerHandleCount,
 622                 &ChildControllerHandleBuffer
 623                 );
 624       if (!EFI_ERROR (Status)) {
 625         for (ChildIndex = 0; ChildIndex < ChildControllerHandleCount; ChildIndex++) {
 626           Status = gEfiShellProtocol->GetDeviceName(ChildControllerHandleBuffer[ChildIndex], EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
 627
 628           ShellPrintHiiEx(
 629             -1,
 630             -1,
 631             NULL,
 632             STRING_TOKEN (STR_DH_OUTPUT_DRIVER6B),
 633             gShellDriver1HiiHandle,
 634             ConvertHandleToHandleIndex(ChildControllerHandleBuffer[ChildIndex]),
 635             TempStringPointer!=NULL?TempStringPointer:L"<Unknown>"
 636             );
 637           SHELL_FREE_NON_NULL(TempStringPointer);
 638         }
 639
 640         SHELL_FREE_NON_NULL (ChildControllerHandleBuffer);
 641       }
 642     }
 643
 644     SHELL_FREE_NON_NULL (ControllerHandleBuffer);
 645   }
 646
 647   return EFI_SUCCESS;
 648 }
 649
 650 /**
 651   Display information for a handle.
 652
 653   @param[in] TheHandle        The handles to show info on.
 654   @param[in] Verbose          TRUE for extra info, FALSE otherwise.
 655   @param[in] Sfo              TRUE to output in standard format output (spec).
 656   @param[in] Language         Language string per UEFI specification.
 657   @param[in] DriverInfo       TRUE to show all info about the handle.
 658   @param[in] Multiple         TRUE indicates more than  will be output,
 659                               FALSE for a single one.
 660
 661   @retval SHELL_SUCCESS           The operation was successful.
 662   @retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
 663 **/
 664 SHELL_STATUS
 665 EFIAPI
 666 DoDhByHandle(
 667   IN CONST EFI_HANDLE TheHandle,
 668   IN CONST BOOLEAN    Verbose,
 669   IN CONST BOOLEAN    Sfo,
 670   IN CONST CHAR8      *Language,
 671   IN CONST BOOLEAN    DriverInfo,
 672   IN CONST BOOLEAN    Multiple
 673   )
 674 {
 675   CHAR16              *ProtocolInfoString;
 676   SHELL_STATUS        ShellStatus;
 677   EFI_STATUS          Status;
 678
 679   Status              = EFI_SUCCESS;
 680   ShellStatus         = SHELL_SUCCESS;
 681   ProtocolInfoString  = NULL;
 682
 683   if (!Sfo) {
 684     if (Multiple) {
 685       ProtocolInfoString = GetProtocolInfoString(TheHandle, Language, L" ", Verbose, TRUE);
 686       ShellPrintHiiEx(
 687         -1,
 688         -1,
 689         NULL,
 690         STRING_TOKEN (STR_DH_OUTPUT),
 691         gShellDriver1HiiHandle,
 692         ConvertHandleToHandleIndex(TheHandle),
 693         ProtocolInfoString==NULL?L"":ProtocolInfoString);
 694     } else {
 695       ProtocolInfoString = GetProtocolInfoString(TheHandle, Language, L"\r\n", Verbose, TRUE);
 696       ShellPrintHiiEx(
 697         -1,
 698         -1,
 699         NULL,
 700         STRING_TOKEN (STR_DH_OUTPUT_SINGLE),
 701         gShellDriver1HiiHandle,
 702         ConvertHandleToHandleIndex(TheHandle),
 703         TheHandle,
 704         ProtocolInfoString==NULL?L"":ProtocolInfoString);
 705     }
 706
 707     if (DriverInfo) {
 708       DisplayDriverModelHandle ((EFI_HANDLE)TheHandle, TRUE, Language);
 709     }
 710   } else {
 711       ProtocolInfoString = GetProtocolInfoString(TheHandle, Language, L";", FALSE, FALSE);
 712       ShellPrintHiiEx(
 713         -1,
 714         -1,
 715         NULL,
 716         STRING_TOKEN (STR_DH_OUTPUT_SFO),
 717         gShellDriver1HiiHandle,
 718         Multiple ?L"HandlesInfo":L"HandleInfo",
 719         L"DriverName",
 720         L"ControllerName",
 721         ConvertHandleToHandleIndex(TheHandle),
 722         L"DevPath",
 723         ProtocolInfoString==NULL?L"":ProtocolInfoString);
 724
 725
 726   }
 727
 728
 729   if (ProtocolInfoString != NULL) {
 730     FreePool(ProtocolInfoString);
 731   }
 732   return (ShellStatus);
 733 }
 734
 735 /**
 736   Display information for all handles on a list.
 737
 738   @param[in] HandleList       The NULL-terminated list of handles.
 739   @param[in] Verbose          TRUE for extra info, FALSE otherwise.
 740   @param[in] Sfo              TRUE to output in standard format output (spec).
 741   @param[in] Language         Language string per UEFI specification.
 742   @param[in] DriverInfo       TRUE to show all info about the handle.
 743
 744   @retval SHELL_SUCCESS           The operation was successful.
 745   @retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
 746 **/
 747 SHELL_STATUS
 748 EFIAPI
 749 DoDhForHandleList(
 750   IN CONST EFI_HANDLE *HandleList,
 751   IN CONST BOOLEAN    Verbose,
 752   IN CONST BOOLEAN    Sfo,
 753   IN CONST CHAR8      *Language,
 754   IN CONST BOOLEAN    DriverInfo
 755   )
 756 {
 757   CONST EFI_HANDLE  *HandleWalker;
 758   SHELL_STATUS      ShellStatus;
 759
 760   ShellStatus       = SHELL_SUCCESS;
 761
 762   for (HandleWalker = HandleList ; HandleWalker != NULL && *HandleWalker != NULL && ShellStatus == SHELL_SUCCESS; HandleWalker++) {
 763     ShellStatus = DoDhByHandle(
 764           *HandleWalker,
 765           Verbose,
 766           Sfo,
 767           Language,
 768           DriverInfo,
 769           TRUE
 770          );
 771   }
 772   return (ShellStatus);
 773 }
 774
 775 /**
 776   Display information for all handles.
 777
 778   @param[in] Sfo              TRUE to output in standard format output (spec).
 779   @param[in] Verbose          TRUE for extra info, FALSE otherwise.
 780   @param[in] Language         Language string per UEFI specification.
 781   @param[in] DriverInfo       TRUE to show all info about the handle.
 782
 783   @retval SHELL_SUCCESS           The operation was successful.
 784   @retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
 785 **/
 786 SHELL_STATUS
 787 EFIAPI
 788 DoDhForAll(
 789   IN CONST BOOLEAN  Sfo,
 790   IN CONST BOOLEAN  Verbose,
 791   IN CONST CHAR8    *Language,
 792   IN CONST BOOLEAN  DriverInfo
 793   )
 794 {
 795   EFI_HANDLE    *HandleList;
 796   SHELL_STATUS  ShellStatus;
 797
 798   HandleList = GetHandleListByProtocol(NULL);
 799
 800   ShellStatus = DoDhForHandleList(
 801     HandleList,
 802     Verbose,
 803     Sfo,
 804     Language,
 805     DriverInfo);
 806
 807   FreePool(HandleList);
 808
 809   return (ShellStatus);
 810 }
 811
 812 /**
 813   Display information for all handles which have a specific protocol.
 814
 815   @param[in] ProtocolName     The pointer to the name of the protocol.
 816   @param[in] Verbose          TRUE for extra info, FALSE otherwise.
 817   @param[in] Sfo              TRUE to output in standard format output (spec).
 818   @param[in] Language         Language string per UEFI specification.
 819   @param[in] DriverInfo       TRUE to show all info about the handle.
 820
 821   @retval SHELL_SUCCESS           The operation was successful.
 822   @retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
 823 **/
 824 SHELL_STATUS
 825 EFIAPI
 826 DoDhByProtocol(
 827   IN CONST CHAR16   *ProtocolName,
 828   IN CONST BOOLEAN  Verbose,
 829   IN CONST BOOLEAN  Sfo,
 830   IN CONST CHAR8    *Language,
 831   IN CONST BOOLEAN  DriverInfo
 832   )
 833 {
 834   EFI_GUID      *Guid;
 835   EFI_STATUS    Status;
 836   EFI_HANDLE    *HandleList;
 837   SHELL_STATUS  ShellStatus;
 838
 839   if (ProtocolName == NULL) {
 840     return (SHELL_INVALID_PARAMETER);
 841   }
 842
 843   Status = GetGuidFromStringName(ProtocolName, Language, &Guid);
 844   if (EFI_ERROR(Status)) {
 845     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DH_NO_GUID_FOUND), gShellDriver1HiiHandle, ProtocolName);
 846     return (SHELL_INVALID_PARAMETER);
 847   }
 848
 849   HandleList = GetHandleListByProtocol(Guid);
 850
 851   ShellStatus = DoDhForHandleList(
 852     HandleList,
 853     Verbose,
 854     Sfo,
 855     Language,
 856     DriverInfo);
 857
 858   SHELL_FREE_NON_NULL(HandleList);
 859
 860   return (ShellStatus);
 861 }
 862
 863 /**
 864   Function for 'dh' command.
 865
 866   @param[in] ImageHandle  Handle to the Image (NULL if Internal).
 867   @param[in] SystemTable  Pointer to the System Table (NULL if Internal).
 868 **/
 869 SHELL_STATUS
 870 EFIAPI
 871 ShellCommandRunDh (
 872   IN EFI_HANDLE        ImageHandle,
 873   IN EFI_SYSTEM_TABLE  *SystemTable
 874   )
 875 {
 876   EFI_STATUS          Status;
 877   LIST_ENTRY          *Package;
 878   CHAR16              *ProblemParam;
 879   SHELL_STATUS        ShellStatus;
 880   CHAR8               *Language;
 881   CONST CHAR16        *Lang;
 882   CONST CHAR16        *Temp2;
 883   BOOLEAN             SfoMode;
 884   BOOLEAN             FlagD;
 885   BOOLEAN             Verbose;
 886   UINT64              Intermediate;
 887
 888   ShellStatus         = SHELL_SUCCESS;
 889   Status              = EFI_SUCCESS;
 890   Language            = NULL;
 891
 892   //
 893   // initialize the shell lib (we must be in non-auto-init...)
 894   //
 895   Status = ShellInitialize();
 896   ASSERT_EFI_ERROR(Status);
 897
 898   Status = CommandInit();
 899   ASSERT_EFI_ERROR(Status);
 900
 901   //
 902   // parse the command line
 903   //
 904   Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);
 905   if (EFI_ERROR(Status)) {
 906     if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {
 907       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDriver1HiiHandle, ProblemParam);
 908       FreePool(ProblemParam);
 909       ShellStatus = SHELL_INVALID_PARAMETER;
 910     } else {
 911       ASSERT(FALSE);
 912     }
 913   } else {
 914     if (ShellCommandLineGetCount(Package) > 2) {
 915       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle);
 916       ShellCommandLineFreeVarList (Package);
 917       return (SHELL_INVALID_PARAMETER);
 918     }
 919
 920     Lang = ShellCommandLineGetValue(Package, L"-l");
 921     if (Lang != NULL) {
 922       Language = AllocateZeroPool(StrSize(Lang));
 923       AsciiSPrint(Language, StrSize(Lang), "%S", Lang);
 924     } else if (!ShellCommandLineGetFlag(Package, L"-l")){
 925       Language = AllocateZeroPool(10);
 926       AsciiSPrint(Language, 10, "en-us");
 927     } else {
 928       ASSERT(Language == NULL);
 929       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"-l");
 930       ShellCommandLineFreeVarList (Package);
 931       return (SHELL_INVALID_PARAMETER);
 932     }
 933
 934     SfoMode = ShellCommandLineGetFlag(Package, L"-sfo");
 935     FlagD   = ShellCommandLineGetFlag(Package, L"-d");
 936     Verbose = (BOOLEAN)(ShellCommandLineGetFlag(Package, L"-v") || ShellCommandLineGetFlag(Package, L"-verbose"));
 937
 938     if (ShellCommandLineGetFlag(Package, L"-p")) {
 939       if (ShellCommandLineGetCount(Package) > 1) {
 940         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle);
 941         ShellStatus = SHELL_INVALID_PARAMETER;
 942       } else if (ShellCommandLineGetValue(Package, L"-p") == NULL) {
 943         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"-p");
 944         ShellStatus = SHELL_INVALID_PARAMETER;
 945       } else {
 946         //
 947         // print by protocol
 948         //
 949         ShellStatus = DoDhByProtocol(
 950           ShellCommandLineGetValue(Package, L"-p"),
 951           Verbose,
 952           SfoMode,
 953           Lang==NULL?NULL:Language,
 954           FlagD
 955          );
 956       }
 957     } else {
 958       Temp2 = ShellCommandLineGetRawValue(Package, 1);
 959       if (Temp2 == NULL) {
 960         //
 961         // Print everything
 962         //
 963         ShellStatus = DoDhForAll(
 964           SfoMode,
 965           Verbose,
 966           Lang==NULL?NULL:Language,
 967           FlagD
 968          );
 969       } else {
 970         Status = ShellConvertStringToUint64(Temp2, &Intermediate, TRUE, FALSE);
 971         if (EFI_ERROR(Status) || ConvertHandleIndexToHandle((UINTN)Intermediate) == NULL) {
 972           ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, Temp2);
 973           ShellStatus = SHELL_INVALID_PARAMETER;
 974         } else {
 975           //
 976           // print 1 handle
 977           //
 978           ShellStatus = DoDhByHandle(
 979             ConvertHandleIndexToHandle((UINTN)Intermediate),
 980             Verbose,
 981             SfoMode,
 982             Lang==NULL?NULL:Language,
 983             FlagD,
 984             FALSE
 985            );
 986         }
 987       }
 988     }
 989
 990
 991     ShellCommandLineFreeVarList (Package);
 992     SHELL_FREE_NON_NULL(Language);
 993   }
 994
 995   return (ShellStatus);
 996 }