ShellPkg/Library/UefiShellDriver1CommandsLib/Dh.c

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