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")\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 (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] Verbose          TRUE for extra info, FALSE otherwise.
 732   @param[in] Sfo              TRUE to output in standard format output (spec).
 733   @param[in] Language         Language string per UEFI specification.
 734   @param[in] DriverInfo       TRUE to show all info about the handle.
 735
 736   @retval SHELL_SUCCESS           The operation was successful.
 737   @retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
 738 **/
 739 SHELL_STATUS
 740 EFIAPI
 741 DoDhForHandleList(
 742   IN CONST EFI_HANDLE *HandleList,
 743   IN CONST BOOLEAN    Verbose,
 744   IN CONST BOOLEAN    Sfo,
 745   IN CONST CHAR8      *Language,
 746   IN CONST BOOLEAN    DriverInfo
 747   )
 748 {
 749   CONST EFI_HANDLE  *HandleWalker;
 750   SHELL_STATUS      ShellStatus;
 751
 752   ShellStatus       = SHELL_SUCCESS;
 753
 754   for (HandleWalker = HandleList ; HandleWalker != NULL && *HandleWalker != NULL && ShellStatus == SHELL_SUCCESS; HandleWalker++) {
 755     ShellStatus = DoDhByHandle(
 756           *HandleWalker,
 757           Verbose,
 758           Sfo,
 759           Language,
 760           DriverInfo,
 761           TRUE
 762          );
 763   }
 764   return (ShellStatus);
 765 }
 766
 767 /**
 768   Display information for all handles.
 769
 770   @param[in] Sfo              TRUE to output in standard format output (spec).
 771   @param[in] Verbose          TRUE for extra info, FALSE otherwise.
 772   @param[in] Language         Language string per UEFI specification.
 773   @param[in] DriverInfo       TRUE to show all info about the handle.
 774
 775   @retval SHELL_SUCCESS           The operation was successful.
 776   @retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
 777 **/
 778 SHELL_STATUS
 779 EFIAPI
 780 DoDhForAll(
 781   IN CONST BOOLEAN  Sfo,
 782   IN CONST BOOLEAN  Verbose,
 783   IN CONST CHAR8    *Language,
 784   IN CONST BOOLEAN  DriverInfo
 785   )
 786 {
 787   EFI_HANDLE    *HandleList;
 788   SHELL_STATUS  ShellStatus;
 789
 790   HandleList = GetHandleListByProtocol(NULL);
 791
 792   ShellStatus = DoDhForHandleList(
 793     HandleList,
 794     Verbose,
 795     Sfo,
 796     Language,
 797     DriverInfo);
 798
 799   FreePool(HandleList);
 800
 801   return (ShellStatus);
 802 }
 803
 804 /**
 805   Display information for all handles which have a specific protocol.
 806
 807   @param[in] ProtocolName     The pointer to the name of the protocol.
 808   @param[in] Verbose          TRUE for extra info, FALSE otherwise.
 809   @param[in] Sfo              TRUE to output in standard format output (spec).
 810   @param[in] Language         Language string per UEFI specification.
 811   @param[in] DriverInfo       TRUE to show all info about the handle.
 812
 813   @retval SHELL_SUCCESS           The operation was successful.
 814   @retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
 815 **/
 816 SHELL_STATUS
 817 EFIAPI
 818 DoDhByProtocol(
 819   IN CONST CHAR16   *ProtocolName,
 820   IN CONST BOOLEAN  Verbose,
 821   IN CONST BOOLEAN  Sfo,
 822   IN CONST CHAR8    *Language,
 823   IN CONST BOOLEAN  DriverInfo
 824   )
 825 {
 826   EFI_GUID      *Guid;
 827   EFI_STATUS    Status;
 828   EFI_HANDLE    *HandleList;
 829   SHELL_STATUS  ShellStatus;
 830
 831   if (ProtocolName == NULL) {
 832     return (SHELL_INVALID_PARAMETER);
 833   }
 834
 835   Status = GetGuidFromStringName(ProtocolName, Language, &Guid);
 836   if (EFI_ERROR(Status)) {
 837     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DH_NO_GUID_FOUND), gShellDriver1HiiHandle, ProtocolName);
 838     return (SHELL_INVALID_PARAMETER);
 839   }
 840
 841   HandleList = GetHandleListByProtocol(Guid);
 842
 843   ShellStatus = DoDhForHandleList(
 844     HandleList,
 845     Verbose,
 846     Sfo,
 847     Language,
 848     DriverInfo);
 849
 850   SHELL_FREE_NON_NULL(HandleList);
 851
 852   return (ShellStatus);
 853 }
 854
 855 /**
 856   Function for 'dh' command.
 857
 858   @param[in] ImageHandle  Handle to the Image (NULL if Internal).
 859   @param[in] SystemTable  Pointer to the System Table (NULL if Internal).
 860 **/
 861 SHELL_STATUS
 862 EFIAPI
 863 ShellCommandRunDh (
 864   IN EFI_HANDLE        ImageHandle,
 865   IN EFI_SYSTEM_TABLE  *SystemTable
 866   )
 867 {
 868   EFI_STATUS          Status;
 869   LIST_ENTRY          *Package;
 870   CHAR16              *ProblemParam;
 871   SHELL_STATUS        ShellStatus;
 872   CHAR8               *Language;
 873   CONST CHAR16        *Lang;
 874   CONST CHAR16        *Temp2;
 875   BOOLEAN             SfoMode;
 876   BOOLEAN             FlagD;
 877   BOOLEAN             Verbose;
 878   UINT64              Intermediate;
 879
 880   ShellStatus         = SHELL_SUCCESS;
 881   Status              = EFI_SUCCESS;
 882   Language            = NULL;
 883
 884   //
 885   // initialize the shell lib (we must be in non-auto-init...)
 886   //
 887   Status = ShellInitialize();
 888   ASSERT_EFI_ERROR(Status);
 889
 890   Status = CommandInit();
 891   ASSERT_EFI_ERROR(Status);
 892
 893   //
 894   // parse the command line
 895   //
 896   Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);
 897   if (EFI_ERROR(Status)) {
 898     if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {
 899       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDriver1HiiHandle, ProblemParam);
 900       FreePool(ProblemParam);
 901       ShellStatus = SHELL_INVALID_PARAMETER;
 902     } else {
 903       ASSERT(FALSE);
 904     }
 905   } else {
 906     if (ShellCommandLineGetCount(Package) > 2) {
 907       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle);
 908       ShellCommandLineFreeVarList (Package);
 909       return (SHELL_INVALID_PARAMETER);
 910     }
 911
 912     Lang = ShellCommandLineGetValue(Package, L"-l");
 913     if (Lang != NULL) {
 914       Language = AllocateZeroPool(StrSize(Lang));
 915       AsciiSPrint(Language, StrSize(Lang), "%S", Lang);
 916     } else if (!ShellCommandLineGetFlag(Package, L"-l")){
 917       Language = AllocateZeroPool(10);
 918       AsciiSPrint(Language, 10, "en-us");
 919     } else {
 920       ASSERT(Language == NULL);
 921       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"-l");
 922       ShellCommandLineFreeVarList (Package);
 923       return (SHELL_INVALID_PARAMETER);
 924     }
 925
 926     SfoMode = ShellCommandLineGetFlag(Package, L"-sfo");
 927     FlagD   = ShellCommandLineGetFlag(Package, L"-d");
 928     Verbose = (BOOLEAN)(ShellCommandLineGetFlag(Package, L"-v") || ShellCommandLineGetFlag(Package, L"-verbose"));
 929
 930     if (ShellCommandLineGetFlag(Package, L"-p")) {
 931       if (ShellCommandLineGetCount(Package) > 1) {
 932         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle);
 933         ShellStatus = SHELL_INVALID_PARAMETER;
 934       } else if (ShellCommandLineGetValue(Package, L"-p") == NULL) {
 935         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"-p");
 936         ShellStatus = SHELL_INVALID_PARAMETER;
 937       } else {
 938         //
 939         // print by protocol
 940         //
 941         ShellStatus = DoDhByProtocol(
 942           ShellCommandLineGetValue(Package, L"-p"),
 943           Verbose,
 944           SfoMode,
 945           Lang==NULL?NULL:Language,
 946           FlagD
 947          );
 948       }
 949     } else {
 950       Temp2 = ShellCommandLineGetRawValue(Package, 1);
 951       if (Temp2 == NULL) {
 952         //
 953         // Print everything
 954         //
 955         ShellStatus = DoDhForAll(
 956           SfoMode,
 957           Verbose,
 958           Lang==NULL?NULL:Language,
 959           FlagD
 960          );
 961       } else {
 962         Status = ShellConvertStringToUint64(Temp2, &Intermediate, TRUE, FALSE);
 963         if (EFI_ERROR(Status) || ConvertHandleIndexToHandle((UINTN)Intermediate) == NULL) {
 964           ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, Temp2);
 965           ShellStatus = SHELL_INVALID_PARAMETER;
 966         } else {
 967           //
 968           // print 1 handle
 969           //
 970           ShellStatus = DoDhByHandle(
 971             ConvertHandleIndexToHandle((UINTN)Intermediate),
 972             Verbose,
 973             SfoMode,
 974             Lang==NULL?NULL:Language,
 975             FlagD,
 976             FALSE
 977            );
 978         }
 979       }
 980     }
 981
 982
 983     ShellCommandLineFreeVarList (Package);
 984     SHELL_FREE_NON_NULL(Language);
 985   }
 986
 987   return (ShellStatus);
 988 }