ShellPkg/Library/UefiShellDriver1CommandsLib/Dh.c

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