ShellPkg/Library/UefiShellDriver1CommandsLib/Dh.c

   1 /** @file
   2   Main file for Dh shell Driver1 function.
   3
   4   Copyright (c) 2010 - 2011, 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")", 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 (DriverName == NULL) {
 398           Status = GetDriverImageName (
 399                     DriverBindingHandleBuffer[Index],
 400                     &DriverName
 401                     );
 402         }
 403
 404         if (Image) {
 405           ShellPrintHiiEx(
 406             -1,
 407             -1,
 408             NULL,
 409             STRING_TOKEN (STR_DH_OUTPUT_DRIVER4A),
 410             gShellDriver1HiiHandle,
 411             ConvertHandleToHandleIndex (DriverBindingHandleBuffer[Index]),
 412             DriverName!=NULL?DriverName:L"<Unknown>"
 413             );
 414         } else {
 415           ShellPrintHiiEx(
 416             -1,
 417             -1,
 418             NULL,
 419             STRING_TOKEN (STR_DH_OUTPUT_DRIVER4B),
 420             gShellDriver1HiiHandle,
 421             ConvertHandleToHandleIndex (DriverBindingHandleBuffer[Index]),
 422             DriverName!=NULL?DriverName:L"<Unknown>"
 423             );
 424         }
 425         SHELL_FREE_NON_NULL(DriverName);
 426       }
 427     }
 428
 429     if (ParentControllerHandleCount == 0) {
 430       ShellPrintHiiEx(
 431         -1,
 432         -1,
 433         NULL,
 434         STRING_TOKEN (STR_DH_OUTPUT_DRIVER5),
 435         gShellDriver1HiiHandle,
 436         L"<None>"
 437         );
 438     } else {
 439       ShellPrintHiiEx(
 440         -1,
 441         -1,
 442         NULL,
 443         STRING_TOKEN (STR_DH_OUTPUT_DRIVER5),
 444         gShellDriver1HiiHandle,
 445         L""
 446         );
 447       for (Index = 0; Index < ParentControllerHandleCount; Index++) {
 448         Status = gEfiShellProtocol->GetDeviceName(ParentControllerHandleBuffer[Index], EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
 449         ShellPrintHiiEx(
 450           -1,
 451           -1,
 452           NULL,
 453           STRING_TOKEN (STR_DH_OUTPUT_DRIVER5B),
 454           gShellDriver1HiiHandle,
 455           ConvertHandleToHandleIndex (ParentControllerHandleBuffer[Index]),
 456           TempStringPointer!=NULL?TempStringPointer:L"<Unknown>"
 457           );
 458         SHELL_FREE_NON_NULL(TempStringPointer);
 459       }
 460     }
 461
 462     if (ChildControllerHandleCount == 0) {
 463       ShellPrintHiiEx(
 464         -1,
 465         -1,
 466         NULL,
 467         STRING_TOKEN (STR_DH_OUTPUT_DRIVER6),
 468         gShellDriver1HiiHandle,
 469         L"<None>"
 470         );
 471     } else {
 472       ShellPrintHiiEx(
 473         -1,
 474         -1,
 475         NULL,
 476         STRING_TOKEN (STR_DH_OUTPUT_DRIVER6),
 477         gShellDriver1HiiHandle,
 478         L""
 479         );
 480       for (Index = 0; Index < ChildControllerHandleCount; Index++) {
 481         Status = gEfiShellProtocol->GetDeviceName(ChildControllerHandleBuffer[Index], EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
 482         ShellPrintHiiEx(
 483           -1,
 484           -1,
 485           NULL,
 486           STRING_TOKEN (STR_DH_OUTPUT_DRIVER6B),
 487           gShellDriver1HiiHandle,
 488           ConvertHandleToHandleIndex (ChildControllerHandleBuffer[Index]),
 489           TempStringPointer!=NULL?TempStringPointer:L"<Unknown>"
 490           );
 491         SHELL_FREE_NON_NULL(TempStringPointer);
 492       }
 493     }
 494   }
 495
 496   SHELL_FREE_NON_NULL(DriverBindingHandleBuffer);
 497
 498   SHELL_FREE_NON_NULL(ParentControllerHandleBuffer);
 499
 500   SHELL_FREE_NON_NULL(ChildControllerHandleBuffer);
 501
 502   if (EFI_ERROR (Status)) {
 503     return Status;
 504   }
 505   //
 506   // See if Handle is a driver binding handle and display its details.
 507   //
 508   Status = gBS->OpenProtocol (
 509                 Handle,
 510                 &gEfiDriverBindingProtocolGuid,
 511                 (VOID **) &DriverBinding,
 512                 NULL,
 513                 NULL,
 514                 EFI_OPEN_PROTOCOL_GET_PROTOCOL
 515                 );
 516   if (EFI_ERROR (Status)) {
 517     return EFI_SUCCESS;
 518   }
 519
 520   NumberOfChildren        = 0;
 521   ControllerHandleBuffer  = NULL;
 522   Status = PARSE_HANDLE_DATABASE_DEVICES (
 523             Handle,
 524             &ControllerHandleCount,
 525             &ControllerHandleBuffer
 526             );
 527   if (ControllerHandleCount > 0) {
 528     for (HandleIndex = 0; HandleIndex < ControllerHandleCount; HandleIndex++) {
 529       Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
 530                 Handle,
 531                 ControllerHandleBuffer[HandleIndex],
 532                 &ChildControllerHandleCount,
 533                 NULL
 534                 );
 535       NumberOfChildren += ChildControllerHandleCount;
 536     }
 537   }
 538
 539   Status = GetDriverName (Handle, Language, &DriverName);
 540
 541   ShellPrintHiiEx(
 542     -1,
 543     -1,
 544     NULL,
 545     STRING_TOKEN (STR_DH_OUTPUT_DRIVER6B),
 546     gShellDriver1HiiHandle,
 547     ConvertHandleToHandleIndex(Handle),
 548     DriverName!=NULL?DriverName:L"<Unknown>"
 549     );
 550   SHELL_FREE_NON_NULL(DriverName);
 551   DriverName = NULL;
 552   Status = GetDriverImageName (
 553             Handle,
 554             &DriverName
 555             );
 556   ShellPrintHiiEx(
 557     -1,
 558     -1,
 559     NULL,
 560     STRING_TOKEN (STR_DH_OUTPUT_DRIVER7B),
 561     gShellDriver1HiiHandle,
 562     DriverName!=NULL?DriverName:L"<Unknown>"
 563     );
 564   SHELL_FREE_NON_NULL(DriverName);
 565
 566   ShellPrintHiiEx(
 567     -1,
 568     -1,
 569     NULL,
 570     STRING_TOKEN (STR_DH_OUTPUT_DRIVER8),
 571     gShellDriver1HiiHandle,
 572     DriverBinding->Version,
 573     NumberOfChildren > 0?L"Bus":ControllerHandleCount > 0?L"Device":L"<Unknown>",
 574     ConfigurationStatus?L"YES":L"NO",
 575     DiagnosticsStatus?L"YES":L"NO"
 576     );
 577
 578   if (ControllerHandleCount == 0) {
 579       ShellPrintHiiEx(
 580         -1,
 581         -1,
 582         NULL,
 583         STRING_TOKEN (STR_DH_OUTPUT_DRIVER6),
 584         gShellDriver1HiiHandle,
 585         L"None"
 586         );
 587   } else {
 588     ShellPrintHiiEx(
 589       -1,
 590       -1,
 591       NULL,
 592       STRING_TOKEN (STR_DH_OUTPUT_DRIVER6),
 593       gShellDriver1HiiHandle,
 594       L""
 595       );
 596     for (HandleIndex = 0; HandleIndex < ControllerHandleCount; HandleIndex++) {
 597       Status = gEfiShellProtocol->GetDeviceName(ControllerHandleBuffer[HandleIndex], EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
 598
 599       ShellPrintHiiEx(
 600         -1,
 601         -1,
 602         NULL,
 603         STRING_TOKEN (STR_DH_OUTPUT_DRIVER9B),
 604         gShellDriver1HiiHandle,
 605         ConvertHandleToHandleIndex(ControllerHandleBuffer[HandleIndex]),
 606         TempStringPointer!=NULL?TempStringPointer:L"<Unknown>"
 607         );
 608       SHELL_FREE_NON_NULL(TempStringPointer);
 609
 610       Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
 611                 Handle,
 612                 ControllerHandleBuffer[HandleIndex],
 613                 &ChildControllerHandleCount,
 614                 &ChildControllerHandleBuffer
 615                 );
 616       if (!EFI_ERROR (Status)) {
 617         for (ChildIndex = 0; ChildIndex < ChildControllerHandleCount; ChildIndex++) {
 618           Status = gEfiShellProtocol->GetDeviceName(ChildControllerHandleBuffer[ChildIndex], EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
 619
 620           ShellPrintHiiEx(
 621             -1,
 622             -1,
 623             NULL,
 624             STRING_TOKEN (STR_DH_OUTPUT_DRIVER6B),
 625             gShellDriver1HiiHandle,
 626             ConvertHandleToHandleIndex(ChildControllerHandleBuffer[ChildIndex]),
 627             TempStringPointer!=NULL?TempStringPointer:L"<Unknown>"
 628             );
 629           SHELL_FREE_NON_NULL(TempStringPointer);
 630         }
 631
 632         SHELL_FREE_NON_NULL (ChildControllerHandleBuffer);
 633       }
 634     }
 635
 636     SHELL_FREE_NON_NULL (ControllerHandleBuffer);
 637   }
 638
 639   return EFI_SUCCESS;
 640 }
 641
 642 /**
 643   Display information for a handle.
 644
 645   @param[in] TheHandle        The handles to show info on.
 646   @param[in] Verbose          TRUE for extra info, FALSE otherwise.
 647   @param[in] Sfo              TRUE to output in standard format output (spec).
 648   @param[in] Language         Language string per UEFI specification.
 649   @param[in] DriverInfo       TRUE to show all info about the handle.
 650   @param[in] Multiple         TRUE indicates more than  will be output,
 651                               FALSE for a single one.
 652
 653   @retval SHELL_SUCCESS           The operation was successful.
 654   @retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
 655 **/
 656 SHELL_STATUS
 657 EFIAPI
 658 DoDhByHandle(
 659   IN CONST EFI_HANDLE TheHandle,
 660   IN CONST BOOLEAN    Verbose,
 661   IN CONST BOOLEAN    Sfo,
 662   IN CONST CHAR8      *Language,
 663   IN CONST BOOLEAN    DriverInfo,
 664   IN CONST BOOLEAN    Multiple
 665   )
 666 {
 667   CHAR16              *ProtocolInfoString;
 668   SHELL_STATUS        ShellStatus;
 669   EFI_STATUS          Status;
 670
 671   Status              = EFI_SUCCESS;
 672   ShellStatus         = SHELL_SUCCESS;
 673   ProtocolInfoString  = NULL;
 674
 675   if (!Sfo) {
 676     if (Multiple) {
 677       ProtocolInfoString = GetProtocolInfoString(TheHandle, Language, L" ", Verbose, TRUE);
 678       ShellPrintHiiEx(
 679         -1,
 680         -1,
 681         NULL,
 682         STRING_TOKEN (STR_DH_OUTPUT),
 683         gShellDriver1HiiHandle,
 684         ConvertHandleToHandleIndex(TheHandle),
 685         ProtocolInfoString==NULL?L"":ProtocolInfoString);
 686     } else {
 687       ProtocolInfoString = GetProtocolInfoString(TheHandle, Language, L"\r\n", Verbose, TRUE);
 688       ShellPrintHiiEx(
 689         -1,
 690         -1,
 691         NULL,
 692         STRING_TOKEN (STR_DH_OUTPUT_SINGLE),
 693         gShellDriver1HiiHandle,
 694         ConvertHandleToHandleIndex(TheHandle),
 695         TheHandle,
 696         ProtocolInfoString==NULL?L"":ProtocolInfoString);
 697     }
 698
 699     if (DriverInfo) {
 700       DisplayDriverModelHandle ((EFI_HANDLE)TheHandle, TRUE, Language);
 701     }
 702   } else {
 703       ProtocolInfoString = GetProtocolInfoString(TheHandle, Language, L";", FALSE, FALSE);
 704       ShellPrintHiiEx(
 705         -1,
 706         -1,
 707         NULL,
 708         STRING_TOKEN (STR_DH_OUTPUT_SFO),
 709         gShellDriver1HiiHandle,
 710         Multiple ?L"HandlesInfo":L"HandleInfo",
 711         L"DriverName",
 712         L"ControllerName",
 713         ConvertHandleToHandleIndex(TheHandle),
 714         L"DevPath",
 715         ProtocolInfoString==NULL?L"":ProtocolInfoString);
 716
 717
 718   }
 719
 720
 721   if (ProtocolInfoString != NULL) {
 722     FreePool(ProtocolInfoString);
 723   }
 724   return (ShellStatus);
 725 }
 726
 727 /**
 728   Display information for all handles on a list.
 729
 730   @param[in] HandleList       The NULL-terminated list of handles.
 731   @param[in] Sfo              TRUE to output in standard format output (spec).
 732   @param[in] Language         Language string per UEFI specification.
 733   @param[in] DriverInfo       TRUE to show all info about the handle.
 734
 735   @retval SHELL_SUCCESS           The operation was successful.
 736   @retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
 737 **/
 738 SHELL_STATUS
 739 EFIAPI
 740 DoDhForHandleList(
 741   IN CONST EFI_HANDLE *HandleList,
 742   IN CONST BOOLEAN    Sfo,
 743   IN CONST CHAR8      *Language,
 744   IN CONST BOOLEAN    DriverInfo
 745   )
 746 {
 747   CONST EFI_HANDLE  *HandleWalker;
 748   SHELL_STATUS      ShellStatus;
 749
 750   ShellStatus       = SHELL_SUCCESS;
 751
 752   for (HandleWalker = HandleList ; HandleWalker != NULL && *HandleWalker != NULL && ShellStatus == SHELL_SUCCESS; HandleWalker++) {
 753     ShellStatus = DoDhByHandle(
 754           *HandleWalker,
 755           FALSE,
 756           Sfo,
 757           Language,
 758           DriverInfo,
 759           TRUE
 760          );
 761   }
 762   return (ShellStatus);
 763 }
 764
 765 /**
 766   Display information for all handles.
 767
 768   @param[in] Sfo              TRUE to output in standard format output (spec).
 769   @param[in] Language         Language string per UEFI specification.
 770   @param[in] DriverInfo       TRUE to show all info about the handle.
 771
 772   @retval SHELL_SUCCESS           The operation was successful.
 773   @retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
 774 **/
 775 SHELL_STATUS
 776 EFIAPI
 777 DoDhForAll(
 778   IN CONST BOOLEAN  Sfo,
 779   IN CONST CHAR8    *Language,
 780   IN CONST BOOLEAN  DriverInfo
 781   )
 782 {
 783   EFI_HANDLE    *HandleList;
 784   SHELL_STATUS  ShellStatus;
 785
 786   HandleList = GetHandleListByProtocol(NULL);
 787
 788   ShellStatus = DoDhForHandleList(
 789     HandleList,
 790     Sfo,
 791     Language,
 792     DriverInfo);
 793
 794   FreePool(HandleList);
 795
 796   return (ShellStatus);
 797 }
 798
 799 /**
 800   Display information for all handles which have a specific protocol.
 801
 802   @param[in] ProtocolName     The pointer to the name of the protocol.
 803   @param[in] Sfo              TRUE to output in standard format output (spec).
 804   @param[in] Language         Language string per UEFI specification.
 805   @param[in] DriverInfo       TRUE to show all info about the handle.
 806
 807   @retval SHELL_SUCCESS           The operation was successful.
 808   @retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
 809 **/
 810 SHELL_STATUS
 811 EFIAPI
 812 DoDhByProtocol(
 813   IN CONST CHAR16   *ProtocolName,
 814   IN CONST BOOLEAN  Sfo,
 815   IN CONST CHAR8    *Language,
 816   IN CONST BOOLEAN  DriverInfo
 817   )
 818 {
 819   EFI_GUID      *Guid;
 820   EFI_STATUS    Status;
 821   EFI_HANDLE    *HandleList;
 822   SHELL_STATUS  ShellStatus;
 823
 824   if (ProtocolName == NULL) {
 825     return (SHELL_INVALID_PARAMETER);
 826   }
 827
 828   Status = GetGuidFromStringName(ProtocolName, Language, &Guid);
 829   if (EFI_ERROR(Status)) {
 830     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DH_NO_GUID_FOUND), gShellDriver1HiiHandle, ProtocolName);
 831     return (SHELL_INVALID_PARAMETER);
 832   }
 833
 834   HandleList = GetHandleListByProtocol(Guid);
 835
 836   ShellStatus = DoDhForHandleList(
 837     HandleList,
 838     Sfo,
 839     Language,
 840     DriverInfo);
 841
 842   SHELL_FREE_NON_NULL(HandleList);
 843
 844   return (ShellStatus);
 845 }
 846
 847 /**
 848   Function for 'dh' command.
 849
 850   @param[in] ImageHandle  Handle to the Image (NULL if Internal).
 851   @param[in] SystemTable  Pointer to the System Table (NULL if Internal).
 852 **/
 853 SHELL_STATUS
 854 EFIAPI
 855 ShellCommandRunDh (
 856   IN EFI_HANDLE        ImageHandle,
 857   IN EFI_SYSTEM_TABLE  *SystemTable
 858   )
 859 {
 860   EFI_STATUS          Status;
 861   LIST_ENTRY          *Package;
 862   CHAR16              *ProblemParam;
 863   SHELL_STATUS        ShellStatus;
 864   CHAR8               *Language;
 865   CONST CHAR16        *Lang;
 866   CONST CHAR16        *Temp2;
 867   BOOLEAN             SfoMode;
 868   BOOLEAN             FlagD;
 869   BOOLEAN             Verbose;
 870   UINT64              Intermediate;
 871
 872   ShellStatus         = SHELL_SUCCESS;
 873   Status              = EFI_SUCCESS;
 874   Language            = NULL;
 875
 876   //
 877   // initialize the shell lib (we must be in non-auto-init...)
 878   //
 879   Status = ShellInitialize();
 880   ASSERT_EFI_ERROR(Status);
 881
 882   Status = CommandInit();
 883   ASSERT_EFI_ERROR(Status);
 884
 885   //
 886   // parse the command line
 887   //
 888   Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);
 889   if (EFI_ERROR(Status)) {
 890     if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {
 891       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDriver1HiiHandle, ProblemParam);
 892       FreePool(ProblemParam);
 893       ShellStatus = SHELL_INVALID_PARAMETER;
 894     } else {
 895       ASSERT(FALSE);
 896     }
 897   } else {
 898     if (ShellCommandLineGetCount(Package) > 2) {
 899       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle);
 900       ShellCommandLineFreeVarList (Package);
 901       return (SHELL_INVALID_PARAMETER);
 902     }
 903
 904     Lang = ShellCommandLineGetValue(Package, L"-l");
 905     if (Lang != NULL) {
 906       Language = AllocateZeroPool(StrSize(Lang));
 907       AsciiSPrint(Language, StrSize(Lang), "%S", Lang);
 908     } else if (!ShellCommandLineGetFlag(Package, L"-l")){
 909       Language = AllocateZeroPool(10);
 910       AsciiSPrint(Language, 10, "en-us");
 911     } else {
 912       ASSERT(Language == NULL);
 913       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"-l");
 914       ShellCommandLineFreeVarList (Package);
 915       return (SHELL_INVALID_PARAMETER);
 916     }
 917
 918     SfoMode = ShellCommandLineGetFlag(Package, L"-sfo");
 919     FlagD   = ShellCommandLineGetFlag(Package, L"-d");
 920     Verbose = (BOOLEAN)(ShellCommandLineGetFlag(Package, L"-v") || ShellCommandLineGetFlag(Package, L"-verbose"));
 921
 922     if (ShellCommandLineGetFlag(Package, L"-p")) {
 923       if (ShellCommandLineGetCount(Package) > 1) {
 924         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle);
 925         ShellStatus = SHELL_INVALID_PARAMETER;
 926       } else if (ShellCommandLineGetValue(Package, L"-p") == NULL) {
 927         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"-p");
 928         ShellStatus = SHELL_INVALID_PARAMETER;
 929       } else {
 930         //
 931         // print by protocol
 932         //
 933         ShellStatus = DoDhByProtocol(
 934           ShellCommandLineGetValue(Package, L"-p"),
 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           Lang==NULL?NULL:Language,
 949           FlagD
 950          );
 951       } else {
 952         Status = ShellConvertStringToUint64(Temp2, &Intermediate, TRUE, FALSE);
 953         if (EFI_ERROR(Status) || ConvertHandleIndexToHandle((UINTN)Intermediate) == NULL) {
 954           ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, Temp2);
 955           ShellStatus = SHELL_INVALID_PARAMETER;
 956         } else {
 957           //
 958           // print 1 handle
 959           //
 960           ShellStatus = DoDhByHandle(
 961             ConvertHandleIndexToHandle((UINTN)Intermediate),
 962             Verbose,
 963             SfoMode,
 964             Lang==NULL?NULL:Language,
 965             FlagD,
 966             FALSE
 967            );
 968         }
 969       }
 970     }
 971
 972
 973     ShellCommandLineFreeVarList (Package);
 974     SHELL_FREE_NON_NULL(Language);
 975   }
 976
 977   return (ShellStatus);
 978 }