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 CHAR16 InstanceStr
[17];
292 ProtocolGuidArray
= NULL
;
296 Status
= gBS
->ProtocolsPerHandle (
301 if (!EFI_ERROR (Status
)) {
302 for (ProtocolIndex
= 0; ProtocolIndex
< ArrayCount
; ProtocolIndex
++) {
303 Temp
= GetStringNameFromGuid(ProtocolGuidArray
[ProtocolIndex
], Language
);
304 ASSERT((RetVal
== NULL
&& Size
== 0) || (RetVal
!= NULL
));
306 StrnCatGrow(&RetVal
, &Size
, Separator
, 0);
308 StrnCatGrow(&RetVal
, &Size
, L
"%H", 0);
310 UnicodeSPrint (GuidStr
, sizeof (GuidStr
), L
"%g", ProtocolGuidArray
[ProtocolIndex
]);
311 StrnCatGrow (&RetVal
, &Size
, GuidStr
, 0);
313 StrnCatGrow(&RetVal
, &Size
, Temp
, 0);
316 StrnCatGrow(&RetVal
, &Size
, L
"%N", 0);
319 Status
= gBS
->HandleProtocol (TheHandle
, ProtocolGuidArray
[ProtocolIndex
], &Instance
);
320 if (!EFI_ERROR (Status
)) {
321 StrnCatGrow (&RetVal
, &Size
, L
"(%H", 0);
322 UnicodeSPrint (InstanceStr
, sizeof (InstanceStr
), L
"%x", Instance
);
323 StrnCatGrow (&RetVal
, &Size
, InstanceStr
, 0);
324 StrnCatGrow (&RetVal
, &Size
, L
"%N)", 0);
329 Temp
= GetProtocolInformationDump(TheHandle
, ProtocolGuidArray
[ProtocolIndex
], Verbose
);
331 ASSERT((RetVal
== NULL
&& Size
== 0) || (RetVal
!= NULL
));
333 StrnCatGrow(&RetVal
, &Size
, L
"(", 0);
334 StrnCatGrow(&RetVal
, &Size
, Temp
, 0);
335 StrnCatGrow(&RetVal
, &Size
, L
")", 0);
337 StrnCatGrow(&RetVal
, &Size
, Separator
, 0);
338 StrnCatGrow(&RetVal
, &Size
, Temp
, 0);
346 SHELL_FREE_NON_NULL(ProtocolGuidArray
);
348 if (RetVal
== NULL
) {
352 ASSERT((RetVal
== NULL
&& Size
== 0) || (RetVal
!= NULL
));
353 StrnCatGrow(&RetVal
, &Size
, Separator
, 0);
358 Gets the name of the loaded image.
360 @param[in] TheHandle The handle of the driver to get info on.
361 @param[out] Name The pointer to the pointer. Valid upon a successful return.
363 @retval EFI_SUCCESS The operation was successful.
367 IN EFI_HANDLE TheHandle
,
371 // get loaded image and devicepathtotext on image->Filepath
372 EFI_LOADED_IMAGE_PROTOCOL
*LoadedImage
;
374 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
376 if (TheHandle
== NULL
|| Name
== NULL
) {
377 return (EFI_INVALID_PARAMETER
);
380 Status
= gBS
->OpenProtocol (
382 &gEfiLoadedImageProtocolGuid
,
383 (VOID
**) &LoadedImage
,
386 EFI_OPEN_PROTOCOL_GET_PROTOCOL
388 if (EFI_ERROR(Status
)) {
391 DevicePath
= LoadedImage
->FilePath
;
392 *Name
= ConvertDevicePathToText(DevicePath
, TRUE
, TRUE
);
393 return (EFI_SUCCESS
);
397 Display driver model information for a given handle.
399 @param[in] Handle The handle to display info on.
400 @param[in] BestName Use the best name?
401 @param[in] Language The language to output in.
404 DisplayDriverModelHandle (
405 IN EFI_HANDLE Handle
,
407 IN CONST CHAR8
*Language OPTIONAL
411 BOOLEAN ConfigurationStatus
;
412 BOOLEAN DiagnosticsStatus
;
413 UINTN DriverBindingHandleCount
;
414 EFI_HANDLE
*DriverBindingHandleBuffer
;
415 UINTN ParentControllerHandleCount
;
416 EFI_HANDLE
*ParentControllerHandleBuffer
;
417 UINTN ChildControllerHandleCount
;
418 EFI_HANDLE
*ChildControllerHandleBuffer
;
419 CHAR16
*TempStringPointer
;
420 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
423 EFI_DRIVER_BINDING_PROTOCOL
*DriverBinding
;
424 UINTN NumberOfChildren
;
426 UINTN ControllerHandleCount
;
427 EFI_HANDLE
*ControllerHandleBuffer
;
434 // See if Handle is a device handle and display its details.
436 DriverBindingHandleBuffer
= NULL
;
437 Status
= PARSE_HANDLE_DATABASE_UEFI_DRIVERS (
439 &DriverBindingHandleCount
,
440 &DriverBindingHandleBuffer
443 ParentControllerHandleBuffer
= NULL
;
444 Status
= PARSE_HANDLE_DATABASE_PARENTS (
446 &ParentControllerHandleCount
,
447 &ParentControllerHandleBuffer
450 ChildControllerHandleBuffer
= NULL
;
451 Status
= ParseHandleDatabaseForChildControllers (
453 &ChildControllerHandleCount
,
454 &ChildControllerHandleBuffer
457 DiagnosticsStatus
= FALSE
;
458 ConfigurationStatus
= FALSE
;
460 if (!EFI_ERROR(gBS
->OpenProtocol(Handle
, &gEfiDriverConfigurationProtocolGuid
, NULL
, NULL
, gImageHandle
, EFI_OPEN_PROTOCOL_TEST_PROTOCOL
))) {
461 ConfigurationStatus
= TRUE
;
463 if (!EFI_ERROR(gBS
->OpenProtocol(Handle
, &gEfiDriverConfiguration2ProtocolGuid
, NULL
, NULL
, gImageHandle
, EFI_OPEN_PROTOCOL_TEST_PROTOCOL
))) {
464 ConfigurationStatus
= TRUE
;
466 if (!EFI_ERROR(gBS
->OpenProtocol(Handle
, &gEfiDriverDiagnosticsProtocolGuid
, NULL
, NULL
, gImageHandle
, EFI_OPEN_PROTOCOL_TEST_PROTOCOL
))) {
467 DiagnosticsStatus
= TRUE
;
469 if (!EFI_ERROR(gBS
->OpenProtocol(Handle
, &gEfiDriverDiagnostics2ProtocolGuid
, NULL
, NULL
, gImageHandle
, EFI_OPEN_PROTOCOL_TEST_PROTOCOL
))) {
470 DiagnosticsStatus
= TRUE
;
473 Status
= EFI_SUCCESS
;
475 if (DriverBindingHandleCount
> 0 || ParentControllerHandleCount
> 0 || ChildControllerHandleCount
> 0) {
480 TempStringPointer
= NULL
;
481 Status
= gBS
->HandleProtocol (Handle
, &gEfiDevicePathProtocolGuid
, (VOID
**)&DevicePath
);
483 Status
= gEfiShellProtocol
->GetDeviceName(Handle
, EFI_DEVICE_NAME_USE_COMPONENT_NAME
|EFI_DEVICE_NAME_USE_DEVICE_PATH
, (CHAR8
*)Language
, &TempStringPointer
);
484 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_DH_OUTPUT_DRIVER1
), gShellDriver1HiiHandle
, TempStringPointer
!=NULL
?TempStringPointer
:L
"<Unknown>");
485 SHELL_FREE_NON_NULL(TempStringPointer
);
487 TempStringPointer
= ConvertDevicePathToText(DevicePath
, TRUE
, FALSE
);
492 STRING_TOKEN (STR_DH_OUTPUT_DRIVER2
),
493 gShellDriver1HiiHandle
,
494 TempStringPointer
!=NULL
?TempStringPointer
:L
"<None>",
495 ParentControllerHandleCount
== 0?L
"ROOT":(ChildControllerHandleCount
> 0)?L
"BUS":L
"DEVICE",
496 ConfigurationStatus
?L
"YES":L
"NO",
497 DiagnosticsStatus
?L
"YES":L
"NO"
500 SHELL_FREE_NON_NULL(TempStringPointer
);
502 if (DriverBindingHandleCount
== 0) {
507 STRING_TOKEN (STR_DH_OUTPUT_DRIVER3
),
508 gShellDriver1HiiHandle
,
516 STRING_TOKEN (STR_DH_OUTPUT_DRIVER3
),
517 gShellDriver1HiiHandle
,
520 for (Index
= 0; Index
< DriverBindingHandleCount
; Index
++) {
522 Status
= GetDriverName (
523 DriverBindingHandleBuffer
[Index
],
527 if (EFI_ERROR (Status
)) {
528 Status
= GetDriverImageName (
529 DriverBindingHandleBuffer
[Index
],
532 if (EFI_ERROR (Status
)) {
542 STRING_TOKEN (STR_DH_OUTPUT_DRIVER4A
),
543 gShellDriver1HiiHandle
,
544 ConvertHandleToHandleIndex (DriverBindingHandleBuffer
[Index
]),
545 DriverName
!=NULL
?DriverName
:L
"<Unknown>"
552 STRING_TOKEN (STR_DH_OUTPUT_DRIVER4B
),
553 gShellDriver1HiiHandle
,
554 ConvertHandleToHandleIndex (DriverBindingHandleBuffer
[Index
]),
555 DriverName
!=NULL
?DriverName
:L
"<Unknown>"
558 SHELL_FREE_NON_NULL(DriverName
);
562 if (ParentControllerHandleCount
== 0) {
567 STRING_TOKEN (STR_DH_OUTPUT_DRIVER5
),
568 gShellDriver1HiiHandle
,
576 STRING_TOKEN (STR_DH_OUTPUT_DRIVER5
),
577 gShellDriver1HiiHandle
,
580 for (Index
= 0; Index
< ParentControllerHandleCount
; Index
++) {
581 Status
= gEfiShellProtocol
->GetDeviceName(ParentControllerHandleBuffer
[Index
], EFI_DEVICE_NAME_USE_COMPONENT_NAME
|EFI_DEVICE_NAME_USE_DEVICE_PATH
, (CHAR8
*)Language
, &TempStringPointer
);
586 STRING_TOKEN (STR_DH_OUTPUT_DRIVER5B
),
587 gShellDriver1HiiHandle
,
588 ConvertHandleToHandleIndex (ParentControllerHandleBuffer
[Index
]),
589 TempStringPointer
!=NULL
?TempStringPointer
:L
"<Unknown>"
591 SHELL_FREE_NON_NULL(TempStringPointer
);
595 if (ChildControllerHandleCount
== 0) {
600 STRING_TOKEN (STR_DH_OUTPUT_DRIVER6
),
601 gShellDriver1HiiHandle
,
609 STRING_TOKEN (STR_DH_OUTPUT_DRIVER6
),
610 gShellDriver1HiiHandle
,
613 for (Index
= 0; Index
< ChildControllerHandleCount
; Index
++) {
614 Status
= gEfiShellProtocol
->GetDeviceName(ChildControllerHandleBuffer
[Index
], EFI_DEVICE_NAME_USE_COMPONENT_NAME
|EFI_DEVICE_NAME_USE_DEVICE_PATH
, (CHAR8
*)Language
, &TempStringPointer
);
619 STRING_TOKEN (STR_DH_OUTPUT_DRIVER6B
),
620 gShellDriver1HiiHandle
,
621 ConvertHandleToHandleIndex (ChildControllerHandleBuffer
[Index
]),
622 TempStringPointer
!=NULL
?TempStringPointer
:L
"<Unknown>"
624 SHELL_FREE_NON_NULL(TempStringPointer
);
629 SHELL_FREE_NON_NULL(DriverBindingHandleBuffer
);
631 SHELL_FREE_NON_NULL(ParentControllerHandleBuffer
);
633 SHELL_FREE_NON_NULL(ChildControllerHandleBuffer
);
635 if (EFI_ERROR (Status
)) {
639 // See if Handle is a driver binding handle and display its details.
641 Status
= gBS
->OpenProtocol (
643 &gEfiDriverBindingProtocolGuid
,
644 (VOID
**) &DriverBinding
,
647 EFI_OPEN_PROTOCOL_GET_PROTOCOL
649 if (EFI_ERROR (Status
)) {
653 NumberOfChildren
= 0;
654 ControllerHandleBuffer
= NULL
;
655 Status
= PARSE_HANDLE_DATABASE_DEVICES (
657 &ControllerHandleCount
,
658 &ControllerHandleBuffer
660 if (ControllerHandleCount
> 0) {
661 for (HandleIndex
= 0; HandleIndex
< ControllerHandleCount
; HandleIndex
++) {
662 Status
= PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
664 ControllerHandleBuffer
[HandleIndex
],
665 &ChildControllerHandleCount
,
668 NumberOfChildren
+= ChildControllerHandleCount
;
672 Status
= GetDriverName (Handle
, Language
, &DriverName
);
673 if (EFI_ERROR (Status
)) {
681 STRING_TOKEN (STR_DH_OUTPUT_DRIVER7
),
682 gShellDriver1HiiHandle
,
683 ConvertHandleToHandleIndex(Handle
),
684 DriverName
!=NULL
?DriverName
:L
"<Unknown>"
686 SHELL_FREE_NON_NULL(DriverName
);
687 Status
= GetDriverImageName (
691 if (EFI_ERROR (Status
)) {
698 STRING_TOKEN (STR_DH_OUTPUT_DRIVER7B
),
699 gShellDriver1HiiHandle
,
700 DriverName
!=NULL
?DriverName
:L
"<Unknown>"
702 SHELL_FREE_NON_NULL(DriverName
);
708 STRING_TOKEN (STR_DH_OUTPUT_DRIVER8
),
709 gShellDriver1HiiHandle
,
710 DriverBinding
->Version
,
711 NumberOfChildren
> 0?L
"Bus":ControllerHandleCount
> 0?L
"Device":L
"<Unknown>",
712 ConfigurationStatus
?L
"YES":L
"NO",
713 DiagnosticsStatus
?L
"YES":L
"NO"
716 if (ControllerHandleCount
== 0) {
721 STRING_TOKEN (STR_DH_OUTPUT_DRIVER9
),
722 gShellDriver1HiiHandle
,
730 STRING_TOKEN (STR_DH_OUTPUT_DRIVER9
),
731 gShellDriver1HiiHandle
,
734 for (HandleIndex
= 0; HandleIndex
< ControllerHandleCount
; HandleIndex
++) {
735 Status
= gEfiShellProtocol
->GetDeviceName(ControllerHandleBuffer
[HandleIndex
], EFI_DEVICE_NAME_USE_COMPONENT_NAME
|EFI_DEVICE_NAME_USE_DEVICE_PATH
, (CHAR8
*)Language
, &TempStringPointer
);
741 STRING_TOKEN (STR_DH_OUTPUT_DRIVER9B
),
742 gShellDriver1HiiHandle
,
743 ConvertHandleToHandleIndex(ControllerHandleBuffer
[HandleIndex
]),
744 TempStringPointer
!=NULL
?TempStringPointer
:L
"<Unknown>"
746 SHELL_FREE_NON_NULL(TempStringPointer
);
748 Status
= PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
750 ControllerHandleBuffer
[HandleIndex
],
751 &ChildControllerHandleCount
,
752 &ChildControllerHandleBuffer
754 if (!EFI_ERROR (Status
)) {
755 for (ChildIndex
= 0; ChildIndex
< ChildControllerHandleCount
; ChildIndex
++) {
756 Status
= gEfiShellProtocol
->GetDeviceName(ChildControllerHandleBuffer
[ChildIndex
], EFI_DEVICE_NAME_USE_COMPONENT_NAME
|EFI_DEVICE_NAME_USE_DEVICE_PATH
, (CHAR8
*)Language
, &TempStringPointer
);
762 STRING_TOKEN (STR_DH_OUTPUT_DRIVER6C
),
763 gShellDriver1HiiHandle
,
764 ConvertHandleToHandleIndex(ChildControllerHandleBuffer
[ChildIndex
]),
765 TempStringPointer
!=NULL
?TempStringPointer
:L
"<Unknown>"
767 SHELL_FREE_NON_NULL(TempStringPointer
);
770 SHELL_FREE_NON_NULL (ChildControllerHandleBuffer
);
774 SHELL_FREE_NON_NULL (ControllerHandleBuffer
);
781 Display information for a handle.
783 @param[in] TheHandle The handles to show info on.
784 @param[in] Verbose TRUE for extra info, FALSE otherwise.
785 @param[in] Sfo TRUE to output in standard format output (spec).
786 @param[in] Language Language string per UEFI specification.
787 @param[in] DriverInfo TRUE to show all info about the handle.
788 @param[in] Multiple TRUE indicates more than will be output,
789 FALSE for a single one.
793 IN CONST EFI_HANDLE TheHandle
,
794 IN CONST BOOLEAN Verbose
,
795 IN CONST BOOLEAN Sfo
,
796 IN CONST CHAR8
*Language
,
797 IN CONST BOOLEAN DriverInfo
,
798 IN CONST BOOLEAN Multiple
801 CHAR16
*ProtocolInfoString
;
803 ProtocolInfoString
= NULL
;
807 ProtocolInfoString
= GetProtocolInfoString(TheHandle
, Language
, L
" ", Verbose
, TRUE
);
812 STRING_TOKEN (STR_DH_OUTPUT
),
813 gShellDriver1HiiHandle
,
814 ConvertHandleToHandleIndex(TheHandle
),
815 ProtocolInfoString
==NULL
?L
"":ProtocolInfoString
818 ProtocolInfoString
= GetProtocolInfoString(TheHandle
, Language
, Verbose
? L
"\r\n" : L
" ", Verbose
, TRUE
);
824 STRING_TOKEN (STR_DH_OUTPUT_SINGLE
),
825 gShellDriver1HiiHandle
,
826 ConvertHandleToHandleIndex(TheHandle
),
828 ProtocolInfoString
==NULL
?L
"":ProtocolInfoString
835 STRING_TOKEN (STR_DH_OUTPUT_SINGLE_D
),
836 gShellDriver1HiiHandle
,
837 ConvertHandleToHandleIndex(TheHandle
),
838 ProtocolInfoString
==NULL
?L
"":ProtocolInfoString
844 DisplayDriverModelHandle ((EFI_HANDLE
)TheHandle
, TRUE
, Language
);
847 ProtocolInfoString
= GetProtocolInfoString(TheHandle
, Language
, L
";", FALSE
, FALSE
);
852 STRING_TOKEN (STR_DH_OUTPUT_SFO
),
853 gShellDriver1HiiHandle
,
854 Multiple
?L
"HandlesInfo":L
"HandleInfo",
857 ConvertHandleToHandleIndex(TheHandle
),
859 ProtocolInfoString
==NULL
?L
"":ProtocolInfoString
863 if (ProtocolInfoString
!= NULL
) {
864 FreePool(ProtocolInfoString
);
869 Display information for all handles on a list.
871 @param[in] HandleList The NULL-terminated list of handles.
872 @param[in] Verbose TRUE for extra info, FALSE otherwise.
873 @param[in] Sfo TRUE to output in standard format output (spec).
874 @param[in] Language Language string per UEFI specification.
875 @param[in] DriverInfo TRUE to show all info about the handle.
877 @retval SHELL_SUCCESS The operation was successful.
878 @retval SHELL_ABORTED The operation was aborted.
882 IN CONST EFI_HANDLE
*HandleList
,
883 IN CONST BOOLEAN Verbose
,
884 IN CONST BOOLEAN Sfo
,
885 IN CONST CHAR8
*Language
,
886 IN CONST BOOLEAN DriverInfo
889 CONST EFI_HANDLE
*HandleWalker
;
890 SHELL_STATUS ShellStatus
;
892 ShellStatus
= SHELL_SUCCESS
;
893 for (HandleWalker
= HandleList
; HandleWalker
!= NULL
&& *HandleWalker
!= NULL
; HandleWalker
++) {
894 DoDhByHandle (*HandleWalker
, Verbose
, Sfo
, Language
, DriverInfo
, TRUE
);
895 if (ShellGetExecutionBreakFlag ()) {
896 ShellStatus
= SHELL_ABORTED
;
900 return (ShellStatus
);
904 Display information for a GUID of protocol.
906 @param[in] Guid The pointer to the name of the protocol.
907 @param[in] Verbose TRUE for extra info, FALSE otherwise.
908 @param[in] Sfo TRUE to output in standard format output (spec).
909 @param[in] Language Language string per UEFI specification.
910 @param[in] DriverInfo TRUE to show all info about the handle.
912 @retval SHELL_SUCCESS The operation was successful.
913 @retval SHELL_NOT_FOUND The GUID was not found.
914 @retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
919 IN CONST BOOLEAN Verbose
,
920 IN CONST BOOLEAN Sfo
,
921 IN CONST CHAR8
*Language
,
922 IN CONST BOOLEAN DriverInfo
926 SHELL_STATUS ShellStatus
;
927 EFI_HANDLE
*HandleList
;
931 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_OUTPUT_ALL_HEADER
), gShellDriver1HiiHandle
);
933 Name
= GetStringNameFromGuid (Guid
, NULL
);
935 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_OUTPUT_GUID_HEADER
), gShellDriver1HiiHandle
, Guid
);
937 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_OUTPUT_NAME_HEADER
), gShellDriver1HiiHandle
, Name
);
941 HandleList
= GetHandleListByProtocol(Guid
);
942 ShellStatus
= DoDhForHandleList(HandleList
, Verbose
, Sfo
, Language
, DriverInfo
);
943 SHELL_FREE_NON_NULL(HandleList
);
949 Function to determine use which method to print information.
950 If Protocol is NULL, The function will print all information.
952 @param[in] Protocol The pointer to the name or GUID of protocol or NULL.
953 @param[in] Verbose TRUE for extra info, FALSE otherwise.
954 @param[in] Sfo TRUE to output in standard format output (spec).
955 @param[in] Language Language string per UEFI specification.
956 @param[in] DriverInfo TRUE to show all info about the handle.
958 @retval SHELL_SUCCESS The operation was successful.
959 @retval SHELL_NOT_FOUND The protocol was not found.
960 @retval SHELL_INVALID_PARAMETER Protocol is invalid parameter.
964 IN CONST CHAR16
*Protocol
,
965 IN CONST BOOLEAN Verbose
,
966 IN CONST BOOLEAN Sfo
,
967 IN CONST CHAR8
*Language
,
968 IN CONST BOOLEAN DriverInfo
975 if (Protocol
== NULL
) {
976 return DoDhByProtocolGuid (NULL
, Verbose
, Sfo
, Language
, DriverInfo
);
978 Status
= ConvertStrToGuid (Protocol
, &Guid
);
979 if (!EFI_ERROR (Status
)) {
983 // Protocol is a Name, convert it to GUID
985 Status
= GetGuidFromStringName (Protocol
, Language
, &GuidPtr
);
986 if (EFI_ERROR(Status
)) {
987 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_NO_NAME_FOUND
), gShellDriver1HiiHandle
, Protocol
);
988 return (SHELL_NOT_FOUND
);
992 return DoDhByProtocolGuid (GuidPtr
, Verbose
, Sfo
, Language
, DriverInfo
);
997 Function to display decode information by Protocol.
998 The parameter Protocol is either a GUID or the name of protocol.
999 If the parameter Protocol is NULL, the function will print all
1002 @param[in] Protocol The pointer to the name or GUID of protocol.
1003 @param[in] Language Language string per UEFI specification.
1005 @retval SHELL_SUCCESS The operation was successful.
1006 @retval SHELL_OUT_OT_RESOURCES A memory allocation failed.
1010 IN CONST CHAR16
*Protocol
,
1011 IN CONST CHAR8
*Language
1021 if (Protocol
== NULL
) {
1023 Status
= GetAllMappingGuids (NULL
, &Counts
);
1024 if (Status
== EFI_BUFFER_TOO_SMALL
) {
1025 Guids
= AllocatePool (Counts
* sizeof(EFI_GUID
));
1026 if (Guids
== NULL
) {
1027 return SHELL_OUT_OF_RESOURCES
;
1030 Status
= GetAllMappingGuids (Guids
, &Counts
);
1031 if (Status
== EFI_SUCCESS
) {
1032 for (Index
= 0; Index
< Counts
; Index
++) {
1033 Name
= GetStringNameFromGuid (&Guids
[Index
], Language
);
1035 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_OUTPUT_DECODE
), gShellDriver1HiiHandle
, Name
, &Guids
[Index
]);
1037 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_NO_GUID_FOUND
), gShellDriver1HiiHandle
, &Guids
[Index
]);
1039 SHELL_FREE_NON_NULL (Name
);
1045 if (ConvertStrToGuid (Protocol
, &Guid
) == EFI_SUCCESS
) {
1046 Name
= GetStringNameFromGuid (&Guid
, Language
);
1048 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_OUTPUT_DECODE
), gShellDriver1HiiHandle
, Name
, &Guid
);
1050 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_NO_GUID_FOUND
), gShellDriver1HiiHandle
, &Guid
);
1052 SHELL_FREE_NON_NULL(Name
);
1054 Status
= GetGuidFromStringName (Protocol
, Language
, &Guids
);
1055 if (Status
== EFI_SUCCESS
) {
1056 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_OUTPUT_DECODE
), gShellDriver1HiiHandle
, Protocol
, Guids
);
1058 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_NO_NAME_FOUND
), gShellDriver1HiiHandle
, Protocol
);
1063 return SHELL_SUCCESS
;
1067 Function for 'dh' command.
1069 @param[in] ImageHandle Handle to the Image (NULL if Internal).
1070 @param[in] SystemTable Pointer to the System Table (NULL if Internal).
1075 IN EFI_HANDLE ImageHandle
,
1076 IN EFI_SYSTEM_TABLE
*SystemTable
1080 LIST_ENTRY
*Package
;
1081 CHAR16
*ProblemParam
;
1082 SHELL_STATUS ShellStatus
;
1085 CONST CHAR16
*RawValue
;
1086 CONST CHAR16
*ProtocolVal
;
1089 BOOLEAN VerboseFlag
;
1090 UINT64 Intermediate
;
1093 ShellStatus
= SHELL_SUCCESS
;
1094 Status
= EFI_SUCCESS
;
1098 // initialize the shell lib (we must be in non-auto-init...)
1100 Status
= ShellInitialize();
1101 ASSERT_EFI_ERROR(Status
);
1103 Status
= CommandInit();
1104 ASSERT_EFI_ERROR(Status
);
1107 // parse the command line
1109 Status
= ShellCommandLineParse (ParamList
, &Package
, &ProblemParam
, TRUE
);
1110 if (EFI_ERROR(Status
)) {
1111 if (Status
== EFI_VOLUME_CORRUPTED
&& ProblemParam
!= NULL
) {
1112 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_GEN_PROBLEM
), gShellDriver1HiiHandle
, L
"dh", ProblemParam
);
1113 FreePool(ProblemParam
);
1114 ShellStatus
= SHELL_INVALID_PARAMETER
;
1119 if (ShellCommandLineGetCount(Package
) > 2) {
1120 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_GEN_TOO_MANY
), gShellDriver1HiiHandle
, L
"dh");
1121 ShellCommandLineFreeVarList (Package
);
1122 return (SHELL_INVALID_PARAMETER
);
1125 if (ShellCommandLineGetFlag(Package
, L
"-l")) {
1126 Lang
= ShellCommandLineGetValue(Package
, L
"-l");
1128 Language
= AllocateZeroPool(StrSize(Lang
));
1129 AsciiSPrint(Language
, StrSize(Lang
), "%S", Lang
);
1131 ASSERT(Language
== NULL
);
1132 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN(STR_GEN_NO_VALUE
), gShellDriver1HiiHandle
, L
"dh", L
"-l");
1133 ShellCommandLineFreeVarList(Package
);
1134 return (SHELL_INVALID_PARAMETER
);
1137 Language
= AllocateZeroPool(10);
1138 AsciiSPrint(Language
, 10, "en-us");
1141 SfoFlag
= ShellCommandLineGetFlag (Package
, L
"-sfo");
1142 DriverFlag
= ShellCommandLineGetFlag (Package
, L
"-d");
1143 VerboseFlag
= (BOOLEAN
)(ShellCommandLineGetFlag (Package
, L
"-v") || ShellCommandLineGetFlag (Package
, L
"-verbose"));
1144 RawValue
= ShellCommandLineGetRawValue (Package
, 1);
1145 ProtocolVal
= ShellCommandLineGetValue (Package
, L
"-p");
1147 if (RawValue
== NULL
) {
1148 if (ShellCommandLineGetFlag (Package
, L
"-p") && (ProtocolVal
== NULL
)) {
1149 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_GEN_NO_VALUE
), gShellDriver1HiiHandle
, L
"dh", L
"-p");
1150 ShellStatus
= SHELL_INVALID_PARAMETER
;
1153 // Print information by protocol, The ProtocolVal maybe is name or GUID or NULL.
1155 ShellStatus
= DoDhByProtocol (ProtocolVal
, VerboseFlag
, SfoFlag
, Language
, DriverFlag
);
1157 } else if ((RawValue
!= NULL
) &&
1158 (gUnicodeCollation
->StriColl(gUnicodeCollation
, L
"decode", (CHAR16
*) RawValue
) == 0)) {
1159 if (ShellCommandLineGetFlag (Package
, L
"-p") && (ProtocolVal
== NULL
)) {
1160 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_GEN_NO_VALUE
), gShellDriver1HiiHandle
, L
"dh", L
"-p");
1161 ShellStatus
= SHELL_INVALID_PARAMETER
;
1164 // Print decode informatino by protocol.
1166 ShellStatus
= DoDecodeByProtocol (ProtocolVal
, Language
);
1169 if (ShellCommandLineGetFlag (Package
, L
"-p")) {
1170 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_GEN_TOO_MANY
), gShellDriver1HiiHandle
, L
"dh");
1171 ShellStatus
= SHELL_INVALID_PARAMETER
;
1173 Status
= ShellConvertStringToUint64 (RawValue
, &Intermediate
, TRUE
, FALSE
);
1174 if (EFI_ERROR(Status
)) {
1175 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_GEN_INV_HANDLE
), gShellDriver1HiiHandle
, L
"dh", RawValue
);
1176 ShellStatus
= SHELL_INVALID_PARAMETER
;
1178 Handle
= ConvertHandleIndexToHandle ((UINTN
) Intermediate
);
1179 if (Handle
== NULL
) {
1180 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_GEN_INV_HANDLE
), gShellDriver1HiiHandle
, L
"dh", RawValue
);
1181 ShellStatus
= SHELL_INVALID_PARAMETER
;
1184 // Print information by handle.
1186 DoDhByHandle (Handle
, VerboseFlag
, SfoFlag
, Language
, DriverFlag
, FALSE
);
1192 ShellCommandLineFreeVarList (Package
);
1193 SHELL_FREE_NON_NULL(Language
);
1196 return (ShellStatus
);