2 Main file for Dh shell Driver1 function.
4 (C) Copyright 2014-2015 Hewlett-Packard Development Company, L.P.<BR>
5 Copyright (c) 2010 - 2017, Intel Corporation. All rights reserved.<BR>
6 (C) Copyright 2017 Hewlett Packard Enterprise Development LP<BR>
7 This program and the accompanying materials
8 are licensed and made available under the terms and conditions of the BSD License
9 which accompanies this distribution. The full text of the license may be found at
10 http://opensource.org/licenses/bsd-license.php
12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
17 #include "UefiShellDriver1CommandsLib.h"
19 STATIC CONST SHELL_PARAM_ITEM ParamList
[] = {
23 {L
"-verbose", TypeFlag
},
29 STATIC CONST EFI_GUID
*UefiDriverModelProtocolsGuidArray
[] = {
30 &gEfiDriverBindingProtocolGuid
,
31 &gEfiPlatformDriverOverrideProtocolGuid
,
32 &gEfiBusSpecificDriverOverrideProtocolGuid
,
33 &gEfiDriverDiagnosticsProtocolGuid
,
34 &gEfiDriverDiagnostics2ProtocolGuid
,
35 &gEfiComponentNameProtocolGuid
,
36 &gEfiComponentName2ProtocolGuid
,
37 &gEfiPlatformToDriverConfigurationProtocolGuid
,
38 &gEfiDriverSupportedEfiVersionProtocolGuid
,
39 &gEfiDriverFamilyOverrideProtocolGuid
,
40 &gEfiDriverHealthProtocolGuid
,
41 &gEfiLoadedImageProtocolGuid
,
45 UINTN mGuidDataLen
[] = {8, 4, 4, 4, 12};
47 Function to determine if the string can convert to a GUID.
48 The string must be restricted as "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" format.
50 @param[in] String The string to test.
52 @retval TRUE The string can convert to a GUID.
53 @retval FALSE The string can't convert to a GUID.
57 IN CONST CHAR16
*String
61 CONST CHAR16
*PrevWalker
;
72 while (Walker
!= NULL
&& *Walker
!= CHAR_NULL
) {
73 if ( (*Walker
>= '0' && *Walker
<= '9') ||
74 (*Walker
>= 'a' && *Walker
<= 'f') ||
75 (*Walker
>= 'A' && *Walker
<= 'F')
79 if (*Walker
== L
'-' && (((UINTN
)Walker
- (UINTN
)PrevWalker
) / sizeof (CHAR16
)) == mGuidDataLen
[Index
]) {
89 if ((((UINTN
)Walker
- (UINTN
)PrevWalker
) / sizeof (CHAR16
)) == mGuidDataLen
[Index
]) {
97 Convert a hex-character to decimal value.
99 This internal function only deal with Unicode character
100 which maps to a valid hexadecimal ASII character, i.e.
101 L'0' to L'9', L'a' to L'f' or L'A' to L'F'. For other
102 Unicode character, the value returned does not make sense.
104 @param[in] Char The character to convert.
106 @retval The numerical value converted.
113 if (Char
>= '0' && Char
<= '9') {
115 } else if (Char
>= 'a' && Char
<= 'f') {
116 return Char
- L
'a' + 10;
118 return Char
- L
'A' + 10;
123 Function try to convert a string to GUID format.
125 @param[in] String The string will be converted.
126 @param[out] Guid Save the result convert from string.
128 @retval EFI_SUCCESS The string was successfully converted to a GUID.
129 @retval EFI_UNSUPPORTED The input string is not in registry format.
133 IN CONST CHAR16
*String
,
137 CONST CHAR16
*Walker
;
141 if (String
== NULL
|| !IsValidGuidString (String
)) {
142 return EFI_UNSUPPORTED
;
148 Guid
->Data1
= (UINT32
)StrHexToUint64 (Walker
);
151 Guid
->Data2
= (UINT16
)StrHexToUint64 (Walker
);
154 Guid
->Data3
= (UINT16
)StrHexToUint64 (Walker
);
157 while (Walker
!= NULL
&& *Walker
!= CHAR_NULL
) {
158 if (*Walker
== L
'-') {
161 TempValue
= (UINT8
)HexCharToDecimal (*Walker
);
162 TempValue
= (UINT8
)LShiftU64 (TempValue
, 4);
165 TempValue
+= (UINT8
)HexCharToDecimal (*Walker
);
168 Guid
->Data4
[Index
] = TempValue
;
177 Get the name of a driver by it's handle.
179 If a name is found the memory must be callee freed.
181 @param[in] TheHandle The driver's handle.
182 @param[in] Language The language to use.
183 @param[in] NameFound Upon a successful return the name found.
185 @retval EFI_SUCCESS The name was found.
189 IN EFI_HANDLE TheHandle
,
190 IN CONST CHAR8
*Language
,
191 IN CHAR16
**NameFound
196 EFI_COMPONENT_NAME2_PROTOCOL
*CompName2
;
197 CHAR16
*NameToReturn
;
199 // Go through those handles until we get one that passes for GetComponentName
201 Status
= gBS
->OpenProtocol(
203 &gEfiComponentName2ProtocolGuid
,
207 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
208 if (EFI_ERROR(Status
)) {
209 Status
= gBS
->OpenProtocol(
211 &gEfiComponentNameProtocolGuid
,
215 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
218 if (EFI_ERROR(Status
)) {
219 return (EFI_NOT_FOUND
);
221 Lang
= GetBestLanguageForDriver (CompName2
->SupportedLanguages
, Language
, FALSE
);
222 Status
= CompName2
->GetDriverName(CompName2
, Lang
, &NameToReturn
);
225 if (!EFI_ERROR(Status
) && NameToReturn
!= NULL
) {
227 StrnCatGrow(NameFound
, NULL
, NameToReturn
, 0);
233 Discover if a protocol guid is one of the UEFI Driver Model Protocols.
235 @param[in] Guid The guid to test.
237 @retval TRUE The guid does represent a driver model protocol.
238 @retval FALSE The guid does not represent a driver model protocol.
242 IN CONST EFI_GUID
*Guid
245 CONST EFI_GUID
**GuidWalker
;
248 for (GuidWalker
= UefiDriverModelProtocolsGuidArray
249 ; GuidWalker
!= NULL
&& *GuidWalker
!= NULL
252 if (CompareGuid(*GuidWalker
, Guid
)) {
261 Get information for a handle.
263 @param[in] TheHandle The handles to show info on.
264 @param[in] Language Language string per UEFI specification.
265 @param[in] Separator Separator string between information blocks.
266 @param[in] Verbose TRUE for extra info, FALSE otherwise.
267 @param[in] ExtraInfo TRUE for extra info, FALSE otherwise.
269 @retval SHELL_SUCCESS The operation was successful.
270 @retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
273 GetProtocolInfoString(
274 IN CONST EFI_HANDLE TheHandle
,
275 IN CONST CHAR8
*Language
,
276 IN CONST CHAR16
*Separator
,
277 IN CONST BOOLEAN Verbose
,
278 IN CONST BOOLEAN ExtraInfo
281 EFI_GUID
**ProtocolGuidArray
;
290 ProtocolGuidArray
= NULL
;
294 Status
= gBS
->ProtocolsPerHandle (
299 if (!EFI_ERROR (Status
)) {
300 for (ProtocolIndex
= 0; ProtocolIndex
< ArrayCount
; ProtocolIndex
++) {
301 Temp
= GetStringNameFromGuid(ProtocolGuidArray
[ProtocolIndex
], Language
);
302 ASSERT((RetVal
== NULL
&& Size
== 0) || (RetVal
!= NULL
));
304 StrnCatGrow(&RetVal
, &Size
, Separator
, 0);
306 StrnCatGrow(&RetVal
, &Size
, L
"%H", 0);
308 UnicodeSPrint (GuidStr
, sizeof (GuidStr
), L
"%g", ProtocolGuidArray
[ProtocolIndex
]);
309 StrnCatGrow (&RetVal
, &Size
, GuidStr
, 0);
311 StrnCatGrow(&RetVal
, &Size
, Temp
, 0);
314 StrnCatGrow(&RetVal
, &Size
, L
"%N", 0);
316 Temp
= GetProtocolInformationDump(TheHandle
, ProtocolGuidArray
[ProtocolIndex
], Verbose
);
318 ASSERT((RetVal
== NULL
&& Size
== 0) || (RetVal
!= NULL
));
320 StrnCatGrow(&RetVal
, &Size
, L
"(", 0);
321 StrnCatGrow(&RetVal
, &Size
, Temp
, 0);
322 StrnCatGrow(&RetVal
, &Size
, L
")", 0);
324 StrnCatGrow(&RetVal
, &Size
, Separator
, 0);
325 StrnCatGrow(&RetVal
, &Size
, Temp
, 0);
333 SHELL_FREE_NON_NULL(ProtocolGuidArray
);
335 if (RetVal
== NULL
) {
339 ASSERT((RetVal
== NULL
&& Size
== 0) || (RetVal
!= NULL
));
340 StrnCatGrow(&RetVal
, &Size
, Separator
, 0);
345 Gets the name of the loaded image.
347 @param[in] TheHandle The handle of the driver to get info on.
348 @param[out] Name The pointer to the pointer. Valid upon a successful return.
350 @retval EFI_SUCCESS The operation was successful.
354 IN EFI_HANDLE TheHandle
,
358 // get loaded image and devicepathtotext on image->Filepath
359 EFI_LOADED_IMAGE_PROTOCOL
*LoadedImage
;
361 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
363 if (TheHandle
== NULL
|| Name
== NULL
) {
364 return (EFI_INVALID_PARAMETER
);
367 Status
= gBS
->OpenProtocol (
369 &gEfiLoadedImageProtocolGuid
,
370 (VOID
**) &LoadedImage
,
373 EFI_OPEN_PROTOCOL_GET_PROTOCOL
375 if (EFI_ERROR(Status
)) {
378 DevicePath
= LoadedImage
->FilePath
;
379 *Name
= ConvertDevicePathToText(DevicePath
, TRUE
, TRUE
);
380 return (EFI_SUCCESS
);
384 Display driver model information for a given handle.
386 @param[in] Handle The handle to display info on.
387 @param[in] BestName Use the best name?
388 @param[in] Language The language to output in.
391 DisplayDriverModelHandle (
392 IN EFI_HANDLE Handle
,
394 IN CONST CHAR8
*Language OPTIONAL
398 BOOLEAN ConfigurationStatus
;
399 BOOLEAN DiagnosticsStatus
;
400 UINTN DriverBindingHandleCount
;
401 EFI_HANDLE
*DriverBindingHandleBuffer
;
402 UINTN ParentControllerHandleCount
;
403 EFI_HANDLE
*ParentControllerHandleBuffer
;
404 UINTN ChildControllerHandleCount
;
405 EFI_HANDLE
*ChildControllerHandleBuffer
;
406 CHAR16
*TempStringPointer
;
407 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
410 EFI_DRIVER_BINDING_PROTOCOL
*DriverBinding
;
411 UINTN NumberOfChildren
;
413 UINTN ControllerHandleCount
;
414 EFI_HANDLE
*ControllerHandleBuffer
;
421 // See if Handle is a device handle and display its details.
423 DriverBindingHandleBuffer
= NULL
;
424 Status
= PARSE_HANDLE_DATABASE_UEFI_DRIVERS (
426 &DriverBindingHandleCount
,
427 &DriverBindingHandleBuffer
430 ParentControllerHandleBuffer
= NULL
;
431 Status
= PARSE_HANDLE_DATABASE_PARENTS (
433 &ParentControllerHandleCount
,
434 &ParentControllerHandleBuffer
437 ChildControllerHandleBuffer
= NULL
;
438 Status
= ParseHandleDatabaseForChildControllers (
440 &ChildControllerHandleCount
,
441 &ChildControllerHandleBuffer
444 DiagnosticsStatus
= FALSE
;
445 ConfigurationStatus
= FALSE
;
447 if (!EFI_ERROR(gBS
->OpenProtocol(Handle
, &gEfiDriverConfigurationProtocolGuid
, NULL
, NULL
, gImageHandle
, EFI_OPEN_PROTOCOL_TEST_PROTOCOL
))) {
448 ConfigurationStatus
= TRUE
;
450 if (!EFI_ERROR(gBS
->OpenProtocol(Handle
, &gEfiDriverConfiguration2ProtocolGuid
, NULL
, NULL
, gImageHandle
, EFI_OPEN_PROTOCOL_TEST_PROTOCOL
))) {
451 ConfigurationStatus
= TRUE
;
453 if (!EFI_ERROR(gBS
->OpenProtocol(Handle
, &gEfiDriverDiagnosticsProtocolGuid
, NULL
, NULL
, gImageHandle
, EFI_OPEN_PROTOCOL_TEST_PROTOCOL
))) {
454 DiagnosticsStatus
= TRUE
;
456 if (!EFI_ERROR(gBS
->OpenProtocol(Handle
, &gEfiDriverDiagnostics2ProtocolGuid
, NULL
, NULL
, gImageHandle
, EFI_OPEN_PROTOCOL_TEST_PROTOCOL
))) {
457 DiagnosticsStatus
= TRUE
;
460 Status
= EFI_SUCCESS
;
462 if (DriverBindingHandleCount
> 0 || ParentControllerHandleCount
> 0 || ChildControllerHandleCount
> 0) {
467 TempStringPointer
= NULL
;
468 Status
= gBS
->HandleProtocol (Handle
, &gEfiDevicePathProtocolGuid
, (VOID
**)&DevicePath
);
470 Status
= gEfiShellProtocol
->GetDeviceName(Handle
, EFI_DEVICE_NAME_USE_COMPONENT_NAME
|EFI_DEVICE_NAME_USE_DEVICE_PATH
, (CHAR8
*)Language
, &TempStringPointer
);
471 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_DH_OUTPUT_DRIVER1
), gShellDriver1HiiHandle
, TempStringPointer
!=NULL
?TempStringPointer
:L
"<Unknown>");
472 SHELL_FREE_NON_NULL(TempStringPointer
);
474 TempStringPointer
= ConvertDevicePathToText(DevicePath
, TRUE
, FALSE
);
479 STRING_TOKEN (STR_DH_OUTPUT_DRIVER2
),
480 gShellDriver1HiiHandle
,
481 TempStringPointer
!=NULL
?TempStringPointer
:L
"<None>",
482 ParentControllerHandleCount
== 0?L
"ROOT":(ChildControllerHandleCount
> 0)?L
"BUS":L
"DEVICE",
483 ConfigurationStatus
?L
"YES":L
"NO",
484 DiagnosticsStatus
?L
"YES":L
"NO"
487 SHELL_FREE_NON_NULL(TempStringPointer
);
489 if (DriverBindingHandleCount
== 0) {
494 STRING_TOKEN (STR_DH_OUTPUT_DRIVER3
),
495 gShellDriver1HiiHandle
,
503 STRING_TOKEN (STR_DH_OUTPUT_DRIVER3
),
504 gShellDriver1HiiHandle
,
507 for (Index
= 0; Index
< DriverBindingHandleCount
; Index
++) {
509 Status
= GetDriverName (
510 DriverBindingHandleBuffer
[Index
],
514 if (EFI_ERROR (Status
)) {
515 Status
= GetDriverImageName (
516 DriverBindingHandleBuffer
[Index
],
519 if (EFI_ERROR (Status
)) {
529 STRING_TOKEN (STR_DH_OUTPUT_DRIVER4A
),
530 gShellDriver1HiiHandle
,
531 ConvertHandleToHandleIndex (DriverBindingHandleBuffer
[Index
]),
532 DriverName
!=NULL
?DriverName
:L
"<Unknown>"
539 STRING_TOKEN (STR_DH_OUTPUT_DRIVER4B
),
540 gShellDriver1HiiHandle
,
541 ConvertHandleToHandleIndex (DriverBindingHandleBuffer
[Index
]),
542 DriverName
!=NULL
?DriverName
:L
"<Unknown>"
545 SHELL_FREE_NON_NULL(DriverName
);
549 if (ParentControllerHandleCount
== 0) {
554 STRING_TOKEN (STR_DH_OUTPUT_DRIVER5
),
555 gShellDriver1HiiHandle
,
563 STRING_TOKEN (STR_DH_OUTPUT_DRIVER5
),
564 gShellDriver1HiiHandle
,
567 for (Index
= 0; Index
< ParentControllerHandleCount
; Index
++) {
568 Status
= gEfiShellProtocol
->GetDeviceName(ParentControllerHandleBuffer
[Index
], EFI_DEVICE_NAME_USE_COMPONENT_NAME
|EFI_DEVICE_NAME_USE_DEVICE_PATH
, (CHAR8
*)Language
, &TempStringPointer
);
573 STRING_TOKEN (STR_DH_OUTPUT_DRIVER5B
),
574 gShellDriver1HiiHandle
,
575 ConvertHandleToHandleIndex (ParentControllerHandleBuffer
[Index
]),
576 TempStringPointer
!=NULL
?TempStringPointer
:L
"<Unknown>"
578 SHELL_FREE_NON_NULL(TempStringPointer
);
582 if (ChildControllerHandleCount
== 0) {
587 STRING_TOKEN (STR_DH_OUTPUT_DRIVER6
),
588 gShellDriver1HiiHandle
,
596 STRING_TOKEN (STR_DH_OUTPUT_DRIVER6
),
597 gShellDriver1HiiHandle
,
600 for (Index
= 0; Index
< ChildControllerHandleCount
; Index
++) {
601 Status
= gEfiShellProtocol
->GetDeviceName(ChildControllerHandleBuffer
[Index
], EFI_DEVICE_NAME_USE_COMPONENT_NAME
|EFI_DEVICE_NAME_USE_DEVICE_PATH
, (CHAR8
*)Language
, &TempStringPointer
);
606 STRING_TOKEN (STR_DH_OUTPUT_DRIVER6B
),
607 gShellDriver1HiiHandle
,
608 ConvertHandleToHandleIndex (ChildControllerHandleBuffer
[Index
]),
609 TempStringPointer
!=NULL
?TempStringPointer
:L
"<Unknown>"
611 SHELL_FREE_NON_NULL(TempStringPointer
);
616 SHELL_FREE_NON_NULL(DriverBindingHandleBuffer
);
618 SHELL_FREE_NON_NULL(ParentControllerHandleBuffer
);
620 SHELL_FREE_NON_NULL(ChildControllerHandleBuffer
);
622 if (EFI_ERROR (Status
)) {
626 // See if Handle is a driver binding handle and display its details.
628 Status
= gBS
->OpenProtocol (
630 &gEfiDriverBindingProtocolGuid
,
631 (VOID
**) &DriverBinding
,
634 EFI_OPEN_PROTOCOL_GET_PROTOCOL
636 if (EFI_ERROR (Status
)) {
640 NumberOfChildren
= 0;
641 ControllerHandleBuffer
= NULL
;
642 Status
= PARSE_HANDLE_DATABASE_DEVICES (
644 &ControllerHandleCount
,
645 &ControllerHandleBuffer
647 if (ControllerHandleCount
> 0) {
648 for (HandleIndex
= 0; HandleIndex
< ControllerHandleCount
; HandleIndex
++) {
649 Status
= PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
651 ControllerHandleBuffer
[HandleIndex
],
652 &ChildControllerHandleCount
,
655 NumberOfChildren
+= ChildControllerHandleCount
;
659 Status
= GetDriverName (Handle
, Language
, &DriverName
);
660 if (EFI_ERROR (Status
)) {
668 STRING_TOKEN (STR_DH_OUTPUT_DRIVER7
),
669 gShellDriver1HiiHandle
,
670 ConvertHandleToHandleIndex(Handle
),
671 DriverName
!=NULL
?DriverName
:L
"<Unknown>"
673 SHELL_FREE_NON_NULL(DriverName
);
674 Status
= GetDriverImageName (
678 if (EFI_ERROR (Status
)) {
685 STRING_TOKEN (STR_DH_OUTPUT_DRIVER7B
),
686 gShellDriver1HiiHandle
,
687 DriverName
!=NULL
?DriverName
:L
"<Unknown>"
689 SHELL_FREE_NON_NULL(DriverName
);
695 STRING_TOKEN (STR_DH_OUTPUT_DRIVER8
),
696 gShellDriver1HiiHandle
,
697 DriverBinding
->Version
,
698 NumberOfChildren
> 0?L
"Bus":ControllerHandleCount
> 0?L
"Device":L
"<Unknown>",
699 ConfigurationStatus
?L
"YES":L
"NO",
700 DiagnosticsStatus
?L
"YES":L
"NO"
703 if (ControllerHandleCount
== 0) {
708 STRING_TOKEN (STR_DH_OUTPUT_DRIVER6
),
709 gShellDriver1HiiHandle
,
717 STRING_TOKEN (STR_DH_OUTPUT_DRIVER6
),
718 gShellDriver1HiiHandle
,
721 for (HandleIndex
= 0; HandleIndex
< ControllerHandleCount
; HandleIndex
++) {
722 Status
= gEfiShellProtocol
->GetDeviceName(ControllerHandleBuffer
[HandleIndex
], EFI_DEVICE_NAME_USE_COMPONENT_NAME
|EFI_DEVICE_NAME_USE_DEVICE_PATH
, (CHAR8
*)Language
, &TempStringPointer
);
728 STRING_TOKEN (STR_DH_OUTPUT_DRIVER9B
),
729 gShellDriver1HiiHandle
,
730 ConvertHandleToHandleIndex(ControllerHandleBuffer
[HandleIndex
]),
731 TempStringPointer
!=NULL
?TempStringPointer
:L
"<Unknown>"
733 SHELL_FREE_NON_NULL(TempStringPointer
);
735 Status
= PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
737 ControllerHandleBuffer
[HandleIndex
],
738 &ChildControllerHandleCount
,
739 &ChildControllerHandleBuffer
741 if (!EFI_ERROR (Status
)) {
742 for (ChildIndex
= 0; ChildIndex
< ChildControllerHandleCount
; ChildIndex
++) {
743 Status
= gEfiShellProtocol
->GetDeviceName(ChildControllerHandleBuffer
[ChildIndex
], EFI_DEVICE_NAME_USE_COMPONENT_NAME
|EFI_DEVICE_NAME_USE_DEVICE_PATH
, (CHAR8
*)Language
, &TempStringPointer
);
749 STRING_TOKEN (STR_DH_OUTPUT_DRIVER6B
),
750 gShellDriver1HiiHandle
,
751 ConvertHandleToHandleIndex(ChildControllerHandleBuffer
[ChildIndex
]),
752 TempStringPointer
!=NULL
?TempStringPointer
:L
"<Unknown>"
754 SHELL_FREE_NON_NULL(TempStringPointer
);
757 SHELL_FREE_NON_NULL (ChildControllerHandleBuffer
);
761 SHELL_FREE_NON_NULL (ControllerHandleBuffer
);
768 Display information for a handle.
770 @param[in] TheHandle The handles to show info on.
771 @param[in] Verbose TRUE for extra info, FALSE otherwise.
772 @param[in] Sfo TRUE to output in standard format output (spec).
773 @param[in] Language Language string per UEFI specification.
774 @param[in] DriverInfo TRUE to show all info about the handle.
775 @param[in] Multiple TRUE indicates more than will be output,
776 FALSE for a single one.
780 IN CONST EFI_HANDLE TheHandle
,
781 IN CONST BOOLEAN Verbose
,
782 IN CONST BOOLEAN Sfo
,
783 IN CONST CHAR8
*Language
,
784 IN CONST BOOLEAN DriverInfo
,
785 IN CONST BOOLEAN Multiple
788 CHAR16
*ProtocolInfoString
;
790 ProtocolInfoString
= NULL
;
794 ProtocolInfoString
= GetProtocolInfoString(TheHandle
, Language
, L
" ", Verbose
, TRUE
);
799 STRING_TOKEN (STR_DH_OUTPUT
),
800 gShellDriver1HiiHandle
,
801 ConvertHandleToHandleIndex(TheHandle
),
802 ProtocolInfoString
==NULL
?L
"":ProtocolInfoString
805 ProtocolInfoString
= GetProtocolInfoString(TheHandle
, Language
, Verbose
? L
"\r\n" : L
" ", Verbose
, TRUE
);
811 STRING_TOKEN (STR_DH_OUTPUT_SINGLE
),
812 gShellDriver1HiiHandle
,
813 ConvertHandleToHandleIndex(TheHandle
),
815 ProtocolInfoString
==NULL
?L
"":ProtocolInfoString
822 STRING_TOKEN (STR_DH_OUTPUT_SINGLE_D
),
823 gShellDriver1HiiHandle
,
824 ConvertHandleToHandleIndex(TheHandle
),
825 ProtocolInfoString
==NULL
?L
"":ProtocolInfoString
831 DisplayDriverModelHandle ((EFI_HANDLE
)TheHandle
, TRUE
, Language
);
834 ProtocolInfoString
= GetProtocolInfoString(TheHandle
, Language
, L
";", FALSE
, FALSE
);
839 STRING_TOKEN (STR_DH_OUTPUT_SFO
),
840 gShellDriver1HiiHandle
,
841 Multiple
?L
"HandlesInfo":L
"HandleInfo",
844 ConvertHandleToHandleIndex(TheHandle
),
846 ProtocolInfoString
==NULL
?L
"":ProtocolInfoString
850 if (ProtocolInfoString
!= NULL
) {
851 FreePool(ProtocolInfoString
);
856 Display information for all handles on a list.
858 @param[in] HandleList The NULL-terminated list of handles.
859 @param[in] Verbose TRUE for extra info, FALSE otherwise.
860 @param[in] Sfo TRUE to output in standard format output (spec).
861 @param[in] Language Language string per UEFI specification.
862 @param[in] DriverInfo TRUE to show all info about the handle.
864 @retval SHELL_SUCCESS The operation was successful.
865 @retval SHELL_ABORTED The operation was aborted.
869 IN CONST EFI_HANDLE
*HandleList
,
870 IN CONST BOOLEAN Verbose
,
871 IN CONST BOOLEAN Sfo
,
872 IN CONST CHAR8
*Language
,
873 IN CONST BOOLEAN DriverInfo
876 CONST EFI_HANDLE
*HandleWalker
;
877 SHELL_STATUS ShellStatus
;
879 ShellStatus
= SHELL_SUCCESS
;
880 for (HandleWalker
= HandleList
; HandleWalker
!= NULL
&& *HandleWalker
!= NULL
; HandleWalker
++) {
881 DoDhByHandle (*HandleWalker
, Verbose
, Sfo
, Language
, DriverInfo
, TRUE
);
882 if (ShellGetExecutionBreakFlag ()) {
883 ShellStatus
= SHELL_ABORTED
;
887 return (ShellStatus
);
891 Display information for a GUID of protocol.
893 @param[in] Guid The pointer to the name of the protocol.
894 @param[in] Verbose TRUE for extra info, FALSE otherwise.
895 @param[in] Sfo TRUE to output in standard format output (spec).
896 @param[in] Language Language string per UEFI specification.
897 @param[in] DriverInfo TRUE to show all info about the handle.
899 @retval SHELL_SUCCESS The operation was successful.
900 @retval SHELL_NOT_FOUND The GUID was not found.
901 @retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
906 IN CONST BOOLEAN Verbose
,
907 IN CONST BOOLEAN Sfo
,
908 IN CONST CHAR8
*Language
,
909 IN CONST BOOLEAN DriverInfo
913 SHELL_STATUS ShellStatus
;
914 EFI_HANDLE
*HandleList
;
918 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_OUTPUT_ALL_HEADER
), gShellDriver1HiiHandle
);
920 Name
= GetStringNameFromGuid (Guid
, NULL
);
922 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_OUTPUT_GUID_HEADER
), gShellDriver1HiiHandle
, Guid
);
924 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_OUTPUT_NAME_HEADER
), gShellDriver1HiiHandle
, Name
);
928 HandleList
= GetHandleListByProtocol(Guid
);
929 ShellStatus
= DoDhForHandleList(HandleList
, Verbose
, Sfo
, Language
, DriverInfo
);
930 SHELL_FREE_NON_NULL(HandleList
);
936 Function to determine use which method to print information.
937 If Protocol is NULL, The function will print all information.
939 @param[in] Protocol The pointer to the name or GUID of protocol or NULL.
940 @param[in] Verbose TRUE for extra info, FALSE otherwise.
941 @param[in] Sfo TRUE to output in standard format output (spec).
942 @param[in] Language Language string per UEFI specification.
943 @param[in] DriverInfo TRUE to show all info about the handle.
945 @retval SHELL_SUCCESS The operation was successful.
946 @retval SHELL_NOT_FOUND The protocol was not found.
947 @retval SHELL_INVALID_PARAMETER Protocol is invalid parameter.
951 IN CONST CHAR16
*Protocol
,
952 IN CONST BOOLEAN Verbose
,
953 IN CONST BOOLEAN Sfo
,
954 IN CONST CHAR8
*Language
,
955 IN CONST BOOLEAN DriverInfo
962 if (Protocol
== NULL
) {
963 return DoDhByProtocolGuid (NULL
, Verbose
, Sfo
, Language
, DriverInfo
);
965 Status
= ConvertStrToGuid (Protocol
, &Guid
);
966 if (!EFI_ERROR (Status
)) {
970 // Protocol is a Name, convert it to GUID
972 Status
= GetGuidFromStringName (Protocol
, Language
, &GuidPtr
);
973 if (EFI_ERROR(Status
)) {
974 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_NO_NAME_FOUND
), gShellDriver1HiiHandle
, Protocol
);
975 return (SHELL_NOT_FOUND
);
979 return DoDhByProtocolGuid (GuidPtr
, Verbose
, Sfo
, Language
, DriverInfo
);
984 Function to display decode information by Protocol.
985 The parameter Protocol is either a GUID or the name of protocol.
986 If the parameter Protocol is NULL, the function will print all
989 @param[in] Protocol The pointer to the name or GUID of protocol.
990 @param[in] Language Language string per UEFI specification.
992 @retval SHELL_SUCCESS The operation was successful.
993 @retval SHELL_OUT_OT_RESOURCES A memory allocation failed.
997 IN CONST CHAR16
*Protocol
,
998 IN CONST CHAR8
*Language
1008 if (Protocol
== NULL
) {
1010 Status
= GetAllMappingGuids (NULL
, &Counts
);
1011 if (Status
== EFI_BUFFER_TOO_SMALL
) {
1012 Guids
= AllocatePool (Counts
* sizeof(EFI_GUID
));
1013 if (Guids
== NULL
) {
1014 return SHELL_OUT_OF_RESOURCES
;
1017 Status
= GetAllMappingGuids (Guids
, &Counts
);
1018 if (Status
== EFI_SUCCESS
) {
1019 for (Index
= 0; Index
< Counts
; Index
++) {
1020 Name
= GetStringNameFromGuid (&Guids
[Index
], Language
);
1022 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_OUTPUT_DECODE
), gShellDriver1HiiHandle
, Name
, &Guids
[Index
]);
1024 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_NO_GUID_FOUND
), gShellDriver1HiiHandle
, &Guids
[Index
]);
1026 SHELL_FREE_NON_NULL (Name
);
1032 if (ConvertStrToGuid (Protocol
, &Guid
) == EFI_SUCCESS
) {
1033 Name
= GetStringNameFromGuid (&Guid
, Language
);
1035 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_OUTPUT_DECODE
), gShellDriver1HiiHandle
, Name
, &Guid
);
1037 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_NO_GUID_FOUND
), gShellDriver1HiiHandle
, &Guid
);
1039 SHELL_FREE_NON_NULL(Name
);
1041 Status
= GetGuidFromStringName (Protocol
, Language
, &Guids
);
1042 if (Status
== EFI_SUCCESS
) {
1043 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_OUTPUT_DECODE
), gShellDriver1HiiHandle
, Protocol
, Guids
);
1045 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_NO_NAME_FOUND
), gShellDriver1HiiHandle
, Protocol
);
1050 return SHELL_SUCCESS
;
1054 Function for 'dh' command.
1056 @param[in] ImageHandle Handle to the Image (NULL if Internal).
1057 @param[in] SystemTable Pointer to the System Table (NULL if Internal).
1062 IN EFI_HANDLE ImageHandle
,
1063 IN EFI_SYSTEM_TABLE
*SystemTable
1067 LIST_ENTRY
*Package
;
1068 CHAR16
*ProblemParam
;
1069 SHELL_STATUS ShellStatus
;
1072 CONST CHAR16
*RawValue
;
1073 CONST CHAR16
*ProtocolVal
;
1076 BOOLEAN VerboseFlag
;
1077 UINT64 Intermediate
;
1080 ShellStatus
= SHELL_SUCCESS
;
1081 Status
= EFI_SUCCESS
;
1085 // initialize the shell lib (we must be in non-auto-init...)
1087 Status
= ShellInitialize();
1088 ASSERT_EFI_ERROR(Status
);
1090 Status
= CommandInit();
1091 ASSERT_EFI_ERROR(Status
);
1094 // parse the command line
1096 Status
= ShellCommandLineParse (ParamList
, &Package
, &ProblemParam
, TRUE
);
1097 if (EFI_ERROR(Status
)) {
1098 if (Status
== EFI_VOLUME_CORRUPTED
&& ProblemParam
!= NULL
) {
1099 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_GEN_PROBLEM
), gShellDriver1HiiHandle
, L
"dh", ProblemParam
);
1100 FreePool(ProblemParam
);
1101 ShellStatus
= SHELL_INVALID_PARAMETER
;
1106 if (ShellCommandLineGetCount(Package
) > 2) {
1107 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_GEN_TOO_MANY
), gShellDriver1HiiHandle
, L
"dh");
1108 ShellCommandLineFreeVarList (Package
);
1109 return (SHELL_INVALID_PARAMETER
);
1112 if (ShellCommandLineGetFlag(Package
, L
"-l")) {
1113 Lang
= ShellCommandLineGetValue(Package
, L
"-l");
1115 Language
= AllocateZeroPool(StrSize(Lang
));
1116 AsciiSPrint(Language
, StrSize(Lang
), "%S", Lang
);
1118 ASSERT(Language
== NULL
);
1119 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN(STR_GEN_NO_VALUE
), gShellDriver1HiiHandle
, L
"dh", L
"-l");
1120 ShellCommandLineFreeVarList(Package
);
1121 return (SHELL_INVALID_PARAMETER
);
1124 Language
= AllocateZeroPool(10);
1125 AsciiSPrint(Language
, 10, "en-us");
1128 SfoFlag
= ShellCommandLineGetFlag (Package
, L
"-sfo");
1129 DriverFlag
= ShellCommandLineGetFlag (Package
, L
"-d");
1130 VerboseFlag
= (BOOLEAN
)(ShellCommandLineGetFlag (Package
, L
"-v") || ShellCommandLineGetFlag (Package
, L
"-verbose"));
1131 RawValue
= ShellCommandLineGetRawValue (Package
, 1);
1132 ProtocolVal
= ShellCommandLineGetValue (Package
, L
"-p");
1134 if (RawValue
== NULL
) {
1135 if (ShellCommandLineGetFlag (Package
, L
"-p") && (ProtocolVal
== NULL
)) {
1136 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_GEN_NO_VALUE
), gShellDriver1HiiHandle
, L
"dh", L
"-p");
1137 ShellStatus
= SHELL_INVALID_PARAMETER
;
1140 // Print information by protocol, The ProtocolVal maybe is name or GUID or NULL.
1142 ShellStatus
= DoDhByProtocol (ProtocolVal
, VerboseFlag
, SfoFlag
, Language
, DriverFlag
);
1144 } else if ((RawValue
!= NULL
) &&
1145 (gUnicodeCollation
->StriColl(gUnicodeCollation
, L
"decode", (CHAR16
*) RawValue
) == 0)) {
1146 if (ShellCommandLineGetFlag (Package
, L
"-p") && (ProtocolVal
== NULL
)) {
1147 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_GEN_NO_VALUE
), gShellDriver1HiiHandle
, L
"dh", L
"-p");
1148 ShellStatus
= SHELL_INVALID_PARAMETER
;
1151 // Print decode informatino by protocol.
1153 ShellStatus
= DoDecodeByProtocol (ProtocolVal
, Language
);
1156 if (ShellCommandLineGetFlag (Package
, L
"-p")) {
1157 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_GEN_TOO_MANY
), gShellDriver1HiiHandle
, L
"dh");
1158 ShellStatus
= SHELL_INVALID_PARAMETER
;
1160 Status
= ShellConvertStringToUint64 (RawValue
, &Intermediate
, TRUE
, FALSE
);
1161 if (EFI_ERROR(Status
)) {
1162 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_GEN_INV_HANDLE
), gShellDriver1HiiHandle
, L
"dh", RawValue
);
1163 ShellStatus
= SHELL_INVALID_PARAMETER
;
1165 Handle
= ConvertHandleIndexToHandle ((UINTN
) Intermediate
);
1166 if (Handle
== NULL
) {
1167 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_GEN_INV_HANDLE
), gShellDriver1HiiHandle
, L
"dh", RawValue
);
1168 ShellStatus
= SHELL_INVALID_PARAMETER
;
1171 // Print information by handle.
1173 DoDhByHandle (Handle
, VerboseFlag
, SfoFlag
, Language
, DriverFlag
, FALSE
);
1179 ShellCommandLineFreeVarList (Package
);
1180 SHELL_FREE_NON_NULL(Language
);
1183 return (ShellStatus
);