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 This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
16 #include "UefiShellDriver1CommandsLib.h"
18 STATIC CONST SHELL_PARAM_ITEM ParamList
[] = {
22 {L
"-verbose", TypeFlag
},
28 STATIC CONST EFI_GUID
*UefiDriverModelProtocolsGuidArray
[] = {
29 &gEfiDriverBindingProtocolGuid
,
30 &gEfiPlatformDriverOverrideProtocolGuid
,
31 &gEfiBusSpecificDriverOverrideProtocolGuid
,
32 &gEfiDriverDiagnosticsProtocolGuid
,
33 &gEfiDriverDiagnostics2ProtocolGuid
,
34 &gEfiComponentNameProtocolGuid
,
35 &gEfiComponentName2ProtocolGuid
,
36 &gEfiPlatformToDriverConfigurationProtocolGuid
,
37 &gEfiDriverSupportedEfiVersionProtocolGuid
,
38 &gEfiDriverFamilyOverrideProtocolGuid
,
39 &gEfiDriverHealthProtocolGuid
,
40 &gEfiLoadedImageProtocolGuid
,
44 UINTN mGuidDataLen
[] = {8, 4, 4, 4, 12};
46 Function to determine if the string can convert to a GUID.
47 The string must be restricted as "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" format.
49 @param[in] String The string to test.
51 @retval TRUE The string can convert to a GUID.
52 @retval FALSE The string can't convert to a GUID.
56 IN CONST CHAR16
*String
60 CONST CHAR16
*PrevWalker
;
71 while (Walker
!= NULL
&& *Walker
!= CHAR_NULL
) {
72 if ( (*Walker
>= '0' && *Walker
<= '9') ||
73 (*Walker
>= 'a' && *Walker
<= 'f') ||
74 (*Walker
>= 'A' && *Walker
<= 'F')
78 if (*Walker
== L
'-' && (UINTN
)(Walker
- PrevWalker
) == mGuidDataLen
[Index
]) {
88 if ((UINTN
)(Walker
- PrevWalker
) == mGuidDataLen
[Index
]) {
96 Convert a hex-character to decimal value.
98 This internal function only deal with Unicode character
99 which maps to a valid hexadecimal ASII character, i.e.
100 L'0' to L'9', L'a' to L'f' or L'A' to L'F'. For other
101 Unicode character, the value returned does not make sense.
103 @param[in] Char The character to convert.
105 @retval The numerical value converted.
112 if (Char
>= '0' && Char
<= '9') {
114 } else if (Char
>= 'a' && Char
<= 'f') {
115 return Char
- L
'a' + 10;
117 return Char
- L
'A' + 10;
122 Function try to convert a string to GUID format.
124 @param[in] String The string will be converted.
125 @param[out] Guid Save the result convert from string.
127 @retval EFI_SUCCESS The string was successfully converted to a GUID.
128 @retval EFI_UNSUPPORTED The input string is not in registry format.
132 IN CONST CHAR16
*String
,
136 CONST CHAR16
*Walker
;
140 if (String
== NULL
|| !IsValidGuidString (String
)) {
141 return EFI_UNSUPPORTED
;
147 Guid
->Data1
= (UINT32
)StrHexToUint64 (Walker
);
150 Guid
->Data2
= (UINT16
)StrHexToUint64 (Walker
);
153 Guid
->Data3
= (UINT16
)StrHexToUint64 (Walker
);
156 while (Walker
!= NULL
&& *Walker
!= CHAR_NULL
) {
157 if (*Walker
== L
'-') {
160 TempValue
= (UINT8
)HexCharToDecimal (*Walker
);
161 TempValue
= (UINT8
)LShiftU64 (TempValue
, 4);
164 TempValue
+= (UINT8
)HexCharToDecimal (*Walker
);
167 Guid
->Data4
[Index
] = TempValue
;
176 Get the name of a driver by it's handle.
178 If a name is found the memory must be callee freed.
180 @param[in] TheHandle The driver's handle.
181 @param[in] Language The language to use.
182 @param[in] NameFound Upon a successful return the name found.
184 @retval EFI_SUCCESS The name was found.
188 IN EFI_HANDLE TheHandle
,
189 IN CONST CHAR8
*Language
,
190 IN CHAR16
**NameFound
195 EFI_COMPONENT_NAME2_PROTOCOL
*CompName2
;
196 CHAR16
*NameToReturn
;
198 // Go through those handles until we get one that passes for GetComponentName
200 Status
= gBS
->OpenProtocol(
202 &gEfiComponentName2ProtocolGuid
,
206 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
207 if (EFI_ERROR(Status
)) {
208 Status
= gBS
->OpenProtocol(
210 &gEfiComponentNameProtocolGuid
,
214 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
217 if (EFI_ERROR(Status
)) {
218 return (EFI_NOT_FOUND
);
220 Lang
= GetBestLanguageForDriver (CompName2
->SupportedLanguages
, Language
, FALSE
);
221 Status
= CompName2
->GetDriverName(CompName2
, Lang
, &NameToReturn
);
224 if (!EFI_ERROR(Status
) && NameToReturn
!= NULL
) {
226 StrnCatGrow(NameFound
, NULL
, NameToReturn
, 0);
232 Discover if a protocol guid is one of the UEFI Driver Model Protocols.
234 @param[in] Guid The guid to test.
236 @retval TRUE The guid does represent a driver model protocol.
237 @retval FALSE The guid does not represent a driver model protocol.
241 IN CONST EFI_GUID
*Guid
244 CONST EFI_GUID
**GuidWalker
;
247 for (GuidWalker
= UefiDriverModelProtocolsGuidArray
248 ; GuidWalker
!= NULL
&& *GuidWalker
!= NULL
251 if (CompareGuid(*GuidWalker
, Guid
)) {
260 Get information for a handle.
262 @param[in] TheHandle The handles to show info on.
263 @param[in] Language Language string per UEFI specification.
264 @param[in] Separator Separator string between information blocks.
265 @param[in] Verbose TRUE for extra info, FALSE otherwise.
266 @param[in] ExtraInfo TRUE for extra info, FALSE otherwise.
268 @retval SHELL_SUCCESS The operation was successful.
269 @retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
272 GetProtocolInfoString(
273 IN CONST EFI_HANDLE TheHandle
,
274 IN CONST CHAR8
*Language
,
275 IN CONST CHAR16
*Separator
,
276 IN CONST BOOLEAN Verbose
,
277 IN CONST BOOLEAN ExtraInfo
280 EFI_GUID
**ProtocolGuidArray
;
289 ProtocolGuidArray
= NULL
;
293 Status
= gBS
->ProtocolsPerHandle (
298 if (!EFI_ERROR (Status
)) {
299 for (ProtocolIndex
= 0; ProtocolIndex
< ArrayCount
; ProtocolIndex
++) {
300 Temp
= GetStringNameFromGuid(ProtocolGuidArray
[ProtocolIndex
], Language
);
301 ASSERT((RetVal
== NULL
&& Size
== 0) || (RetVal
!= NULL
));
303 StrnCatGrow(&RetVal
, &Size
, Separator
, 0);
305 StrnCatGrow(&RetVal
, &Size
, L
"%H", 0);
307 UnicodeSPrint (GuidStr
, sizeof (GuidStr
), L
"%g", ProtocolGuidArray
[ProtocolIndex
]);
308 StrnCatGrow (&RetVal
, &Size
, GuidStr
, 0);
310 StrnCatGrow(&RetVal
, &Size
, Temp
, 0);
313 StrnCatGrow(&RetVal
, &Size
, L
"%N", 0);
315 Temp
= GetProtocolInformationDump(TheHandle
, ProtocolGuidArray
[ProtocolIndex
], Verbose
);
317 ASSERT((RetVal
== NULL
&& Size
== 0) || (RetVal
!= NULL
));
319 StrnCatGrow(&RetVal
, &Size
, L
"(", 0);
320 StrnCatGrow(&RetVal
, &Size
, Temp
, 0);
321 StrnCatGrow(&RetVal
, &Size
, L
")\r\n", 0);
323 StrnCatGrow(&RetVal
, &Size
, Separator
, 0);
324 StrnCatGrow(&RetVal
, &Size
, Temp
, 0);
332 SHELL_FREE_NON_NULL(ProtocolGuidArray
);
334 if (RetVal
== NULL
) {
338 ASSERT((RetVal
== NULL
&& Size
== 0) || (RetVal
!= NULL
));
339 StrnCatGrow(&RetVal
, &Size
, Separator
, 0);
344 Gets the name of the loaded image.
346 @param[in] TheHandle The handle of the driver to get info on.
347 @param[out] Name The pointer to the pointer. Valid upon a successful return.
349 @retval EFI_SUCCESS The operation was successful.
353 IN EFI_HANDLE TheHandle
,
357 // get loaded image and devicepathtotext on image->Filepath
358 EFI_LOADED_IMAGE_PROTOCOL
*LoadedImage
;
360 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
362 if (TheHandle
== NULL
|| Name
== NULL
) {
363 return (EFI_INVALID_PARAMETER
);
366 Status
= gBS
->OpenProtocol (
368 &gEfiLoadedImageProtocolGuid
,
369 (VOID
**) &LoadedImage
,
372 EFI_OPEN_PROTOCOL_GET_PROTOCOL
374 if (EFI_ERROR(Status
)) {
377 DevicePath
= LoadedImage
->FilePath
;
378 *Name
= ConvertDevicePathToText(DevicePath
, TRUE
, TRUE
);
379 return (EFI_SUCCESS
);
383 Display driver model information for a given handle.
385 @param[in] Handle The handle to display info on.
386 @param[in] BestName Use the best name?
387 @param[in] Language The language to output in.
390 DisplayDriverModelHandle (
391 IN EFI_HANDLE Handle
,
393 IN CONST CHAR8
*Language OPTIONAL
397 BOOLEAN ConfigurationStatus
;
398 BOOLEAN DiagnosticsStatus
;
399 UINTN DriverBindingHandleCount
;
400 EFI_HANDLE
*DriverBindingHandleBuffer
;
401 UINTN ParentControllerHandleCount
;
402 EFI_HANDLE
*ParentControllerHandleBuffer
;
403 UINTN ChildControllerHandleCount
;
404 EFI_HANDLE
*ChildControllerHandleBuffer
;
405 CHAR16
*TempStringPointer
;
406 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
409 EFI_DRIVER_BINDING_PROTOCOL
*DriverBinding
;
410 UINTN NumberOfChildren
;
412 UINTN ControllerHandleCount
;
413 EFI_HANDLE
*ControllerHandleBuffer
;
420 // See if Handle is a device handle and display its details.
422 DriverBindingHandleBuffer
= NULL
;
423 Status
= PARSE_HANDLE_DATABASE_UEFI_DRIVERS (
425 &DriverBindingHandleCount
,
426 &DriverBindingHandleBuffer
429 ParentControllerHandleBuffer
= NULL
;
430 Status
= PARSE_HANDLE_DATABASE_PARENTS (
432 &ParentControllerHandleCount
,
433 &ParentControllerHandleBuffer
436 ChildControllerHandleBuffer
= NULL
;
437 Status
= ParseHandleDatabaseForChildControllers (
439 &ChildControllerHandleCount
,
440 &ChildControllerHandleBuffer
443 DiagnosticsStatus
= FALSE
;
444 ConfigurationStatus
= FALSE
;
446 if (!EFI_ERROR(gBS
->OpenProtocol(Handle
, &gEfiDriverConfigurationProtocolGuid
, NULL
, NULL
, gImageHandle
, EFI_OPEN_PROTOCOL_TEST_PROTOCOL
))) {
447 ConfigurationStatus
= TRUE
;
449 if (!EFI_ERROR(gBS
->OpenProtocol(Handle
, &gEfiDriverConfiguration2ProtocolGuid
, NULL
, NULL
, gImageHandle
, EFI_OPEN_PROTOCOL_TEST_PROTOCOL
))) {
450 ConfigurationStatus
= TRUE
;
452 if (!EFI_ERROR(gBS
->OpenProtocol(Handle
, &gEfiDriverDiagnosticsProtocolGuid
, NULL
, NULL
, gImageHandle
, EFI_OPEN_PROTOCOL_TEST_PROTOCOL
))) {
453 DiagnosticsStatus
= TRUE
;
455 if (!EFI_ERROR(gBS
->OpenProtocol(Handle
, &gEfiDriverDiagnostics2ProtocolGuid
, NULL
, NULL
, gImageHandle
, EFI_OPEN_PROTOCOL_TEST_PROTOCOL
))) {
456 DiagnosticsStatus
= TRUE
;
459 Status
= EFI_SUCCESS
;
461 if (DriverBindingHandleCount
> 0 || ParentControllerHandleCount
> 0 || ChildControllerHandleCount
> 0) {
466 TempStringPointer
= NULL
;
467 Status
= gBS
->HandleProtocol (Handle
, &gEfiDevicePathProtocolGuid
, (VOID
**)&DevicePath
);
469 Status
= gEfiShellProtocol
->GetDeviceName(Handle
, EFI_DEVICE_NAME_USE_COMPONENT_NAME
|EFI_DEVICE_NAME_USE_DEVICE_PATH
, (CHAR8
*)Language
, &TempStringPointer
);
470 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_DH_OUTPUT_DRIVER1
), gShellDriver1HiiHandle
, TempStringPointer
!=NULL
?TempStringPointer
:L
"<Unknown>");
471 SHELL_FREE_NON_NULL(TempStringPointer
);
473 TempStringPointer
= ConvertDevicePathToText(DevicePath
, TRUE
, FALSE
);
478 STRING_TOKEN (STR_DH_OUTPUT_DRIVER2
),
479 gShellDriver1HiiHandle
,
480 TempStringPointer
!=NULL
?TempStringPointer
:L
"<None>",
481 ParentControllerHandleCount
== 0?L
"ROOT":(ChildControllerHandleCount
> 0)?L
"BUS":L
"DEVICE",
482 ConfigurationStatus
?L
"YES":L
"NO",
483 DiagnosticsStatus
?L
"YES":L
"NO"
486 SHELL_FREE_NON_NULL(TempStringPointer
);
488 if (DriverBindingHandleCount
== 0) {
493 STRING_TOKEN (STR_DH_OUTPUT_DRIVER3
),
494 gShellDriver1HiiHandle
,
502 STRING_TOKEN (STR_DH_OUTPUT_DRIVER3
),
503 gShellDriver1HiiHandle
,
506 for (Index
= 0; Index
< DriverBindingHandleCount
; Index
++) {
508 Status
= GetDriverName (
509 DriverBindingHandleBuffer
[Index
],
513 if (EFI_ERROR (Status
)) {
514 Status
= GetDriverImageName (
515 DriverBindingHandleBuffer
[Index
],
518 if (EFI_ERROR (Status
)) {
528 STRING_TOKEN (STR_DH_OUTPUT_DRIVER4A
),
529 gShellDriver1HiiHandle
,
530 ConvertHandleToHandleIndex (DriverBindingHandleBuffer
[Index
]),
531 DriverName
!=NULL
?DriverName
:L
"<Unknown>"
538 STRING_TOKEN (STR_DH_OUTPUT_DRIVER4B
),
539 gShellDriver1HiiHandle
,
540 ConvertHandleToHandleIndex (DriverBindingHandleBuffer
[Index
]),
541 DriverName
!=NULL
?DriverName
:L
"<Unknown>"
544 SHELL_FREE_NON_NULL(DriverName
);
548 if (ParentControllerHandleCount
== 0) {
553 STRING_TOKEN (STR_DH_OUTPUT_DRIVER5
),
554 gShellDriver1HiiHandle
,
562 STRING_TOKEN (STR_DH_OUTPUT_DRIVER5
),
563 gShellDriver1HiiHandle
,
566 for (Index
= 0; Index
< ParentControllerHandleCount
; Index
++) {
567 Status
= gEfiShellProtocol
->GetDeviceName(ParentControllerHandleBuffer
[Index
], EFI_DEVICE_NAME_USE_COMPONENT_NAME
|EFI_DEVICE_NAME_USE_DEVICE_PATH
, (CHAR8
*)Language
, &TempStringPointer
);
572 STRING_TOKEN (STR_DH_OUTPUT_DRIVER5B
),
573 gShellDriver1HiiHandle
,
574 ConvertHandleToHandleIndex (ParentControllerHandleBuffer
[Index
]),
575 TempStringPointer
!=NULL
?TempStringPointer
:L
"<Unknown>"
577 SHELL_FREE_NON_NULL(TempStringPointer
);
581 if (ChildControllerHandleCount
== 0) {
586 STRING_TOKEN (STR_DH_OUTPUT_DRIVER6
),
587 gShellDriver1HiiHandle
,
595 STRING_TOKEN (STR_DH_OUTPUT_DRIVER6
),
596 gShellDriver1HiiHandle
,
599 for (Index
= 0; Index
< ChildControllerHandleCount
; Index
++) {
600 Status
= gEfiShellProtocol
->GetDeviceName(ChildControllerHandleBuffer
[Index
], EFI_DEVICE_NAME_USE_COMPONENT_NAME
|EFI_DEVICE_NAME_USE_DEVICE_PATH
, (CHAR8
*)Language
, &TempStringPointer
);
605 STRING_TOKEN (STR_DH_OUTPUT_DRIVER6B
),
606 gShellDriver1HiiHandle
,
607 ConvertHandleToHandleIndex (ChildControllerHandleBuffer
[Index
]),
608 TempStringPointer
!=NULL
?TempStringPointer
:L
"<Unknown>"
610 SHELL_FREE_NON_NULL(TempStringPointer
);
615 SHELL_FREE_NON_NULL(DriverBindingHandleBuffer
);
617 SHELL_FREE_NON_NULL(ParentControllerHandleBuffer
);
619 SHELL_FREE_NON_NULL(ChildControllerHandleBuffer
);
621 if (EFI_ERROR (Status
)) {
625 // See if Handle is a driver binding handle and display its details.
627 Status
= gBS
->OpenProtocol (
629 &gEfiDriverBindingProtocolGuid
,
630 (VOID
**) &DriverBinding
,
633 EFI_OPEN_PROTOCOL_GET_PROTOCOL
635 if (EFI_ERROR (Status
)) {
639 NumberOfChildren
= 0;
640 ControllerHandleBuffer
= NULL
;
641 Status
= PARSE_HANDLE_DATABASE_DEVICES (
643 &ControllerHandleCount
,
644 &ControllerHandleBuffer
646 if (ControllerHandleCount
> 0) {
647 for (HandleIndex
= 0; HandleIndex
< ControllerHandleCount
; HandleIndex
++) {
648 Status
= PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
650 ControllerHandleBuffer
[HandleIndex
],
651 &ChildControllerHandleCount
,
654 NumberOfChildren
+= ChildControllerHandleCount
;
658 Status
= GetDriverName (Handle
, Language
, &DriverName
);
659 if (EFI_ERROR (Status
)) {
667 STRING_TOKEN (STR_DH_OUTPUT_DRIVER6B
),
668 gShellDriver1HiiHandle
,
669 ConvertHandleToHandleIndex(Handle
),
670 DriverName
!=NULL
?DriverName
:L
"<Unknown>"
672 SHELL_FREE_NON_NULL(DriverName
);
673 Status
= GetDriverImageName (
677 if (EFI_ERROR (Status
)) {
684 STRING_TOKEN (STR_DH_OUTPUT_DRIVER7B
),
685 gShellDriver1HiiHandle
,
686 DriverName
!=NULL
?DriverName
:L
"<Unknown>"
688 SHELL_FREE_NON_NULL(DriverName
);
694 STRING_TOKEN (STR_DH_OUTPUT_DRIVER8
),
695 gShellDriver1HiiHandle
,
696 DriverBinding
->Version
,
697 NumberOfChildren
> 0?L
"Bus":ControllerHandleCount
> 0?L
"Device":L
"<Unknown>",
698 ConfigurationStatus
?L
"YES":L
"NO",
699 DiagnosticsStatus
?L
"YES":L
"NO"
702 if (ControllerHandleCount
== 0) {
707 STRING_TOKEN (STR_DH_OUTPUT_DRIVER6
),
708 gShellDriver1HiiHandle
,
716 STRING_TOKEN (STR_DH_OUTPUT_DRIVER6
),
717 gShellDriver1HiiHandle
,
720 for (HandleIndex
= 0; HandleIndex
< ControllerHandleCount
; HandleIndex
++) {
721 Status
= gEfiShellProtocol
->GetDeviceName(ControllerHandleBuffer
[HandleIndex
], EFI_DEVICE_NAME_USE_COMPONENT_NAME
|EFI_DEVICE_NAME_USE_DEVICE_PATH
, (CHAR8
*)Language
, &TempStringPointer
);
727 STRING_TOKEN (STR_DH_OUTPUT_DRIVER9B
),
728 gShellDriver1HiiHandle
,
729 ConvertHandleToHandleIndex(ControllerHandleBuffer
[HandleIndex
]),
730 TempStringPointer
!=NULL
?TempStringPointer
:L
"<Unknown>"
732 SHELL_FREE_NON_NULL(TempStringPointer
);
734 Status
= PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
736 ControllerHandleBuffer
[HandleIndex
],
737 &ChildControllerHandleCount
,
738 &ChildControllerHandleBuffer
740 if (!EFI_ERROR (Status
)) {
741 for (ChildIndex
= 0; ChildIndex
< ChildControllerHandleCount
; ChildIndex
++) {
742 Status
= gEfiShellProtocol
->GetDeviceName(ChildControllerHandleBuffer
[ChildIndex
], EFI_DEVICE_NAME_USE_COMPONENT_NAME
|EFI_DEVICE_NAME_USE_DEVICE_PATH
, (CHAR8
*)Language
, &TempStringPointer
);
748 STRING_TOKEN (STR_DH_OUTPUT_DRIVER6B
),
749 gShellDriver1HiiHandle
,
750 ConvertHandleToHandleIndex(ChildControllerHandleBuffer
[ChildIndex
]),
751 TempStringPointer
!=NULL
?TempStringPointer
:L
"<Unknown>"
753 SHELL_FREE_NON_NULL(TempStringPointer
);
756 SHELL_FREE_NON_NULL (ChildControllerHandleBuffer
);
760 SHELL_FREE_NON_NULL (ControllerHandleBuffer
);
767 Display information for a handle.
769 @param[in] TheHandle The handles to show info on.
770 @param[in] Verbose TRUE for extra info, FALSE otherwise.
771 @param[in] Sfo TRUE to output in standard format output (spec).
772 @param[in] Language Language string per UEFI specification.
773 @param[in] DriverInfo TRUE to show all info about the handle.
774 @param[in] Multiple TRUE indicates more than will be output,
775 FALSE for a single one.
779 IN CONST EFI_HANDLE TheHandle
,
780 IN CONST BOOLEAN Verbose
,
781 IN CONST BOOLEAN Sfo
,
782 IN CONST CHAR8
*Language
,
783 IN CONST BOOLEAN DriverInfo
,
784 IN CONST BOOLEAN Multiple
787 CHAR16
*ProtocolInfoString
;
789 ProtocolInfoString
= NULL
;
793 ProtocolInfoString
= GetProtocolInfoString(TheHandle
, Language
, L
" ", Verbose
, TRUE
);
798 STRING_TOKEN (STR_DH_OUTPUT
),
799 gShellDriver1HiiHandle
,
800 ConvertHandleToHandleIndex(TheHandle
),
801 ProtocolInfoString
==NULL
?L
"":ProtocolInfoString
804 ProtocolInfoString
= GetProtocolInfoString(TheHandle
, Language
, L
"\r\n", Verbose
, TRUE
);
809 STRING_TOKEN (STR_DH_OUTPUT_SINGLE
),
810 gShellDriver1HiiHandle
,
811 ConvertHandleToHandleIndex(TheHandle
),
813 ProtocolInfoString
==NULL
?L
"":ProtocolInfoString
818 DisplayDriverModelHandle ((EFI_HANDLE
)TheHandle
, TRUE
, Language
);
821 ProtocolInfoString
= GetProtocolInfoString(TheHandle
, Language
, L
";", FALSE
, FALSE
);
826 STRING_TOKEN (STR_DH_OUTPUT_SFO
),
827 gShellDriver1HiiHandle
,
828 Multiple
?L
"HandlesInfo":L
"HandleInfo",
831 ConvertHandleToHandleIndex(TheHandle
),
833 ProtocolInfoString
==NULL
?L
"":ProtocolInfoString
837 if (ProtocolInfoString
!= NULL
) {
838 FreePool(ProtocolInfoString
);
843 Display information for all handles on a list.
845 @param[in] HandleList The NULL-terminated list of handles.
846 @param[in] Verbose TRUE for extra info, FALSE otherwise.
847 @param[in] Sfo TRUE to output in standard format output (spec).
848 @param[in] Language Language string per UEFI specification.
849 @param[in] DriverInfo TRUE to show all info about the handle.
851 @retval SHELL_SUCCESS The operation was successful.
852 @retval SHELL_ABORTED The operation was aborted.
856 IN CONST EFI_HANDLE
*HandleList
,
857 IN CONST BOOLEAN Verbose
,
858 IN CONST BOOLEAN Sfo
,
859 IN CONST CHAR8
*Language
,
860 IN CONST BOOLEAN DriverInfo
863 CONST EFI_HANDLE
*HandleWalker
;
864 SHELL_STATUS ShellStatus
;
866 ShellStatus
= SHELL_SUCCESS
;
867 for (HandleWalker
= HandleList
; HandleWalker
!= NULL
&& *HandleWalker
!= NULL
; HandleWalker
++) {
868 DoDhByHandle (*HandleWalker
, Verbose
, Sfo
, Language
, DriverInfo
, TRUE
);
869 if (ShellGetExecutionBreakFlag ()) {
870 ShellStatus
= SHELL_ABORTED
;
874 return (ShellStatus
);
878 Display information for a GUID of protocol.
880 @param[in] Guid The pointer to the name of the protocol.
881 @param[in] Verbose TRUE for extra info, FALSE otherwise.
882 @param[in] Sfo TRUE to output in standard format output (spec).
883 @param[in] Language Language string per UEFI specification.
884 @param[in] DriverInfo TRUE to show all info about the handle.
886 @retval SHELL_SUCCESS The operation was successful.
887 @retval SHELL_NOT_FOUND The GUID was not found.
888 @retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
893 IN CONST BOOLEAN Verbose
,
894 IN CONST BOOLEAN Sfo
,
895 IN CONST CHAR8
*Language
,
896 IN CONST BOOLEAN DriverInfo
900 SHELL_STATUS ShellStatus
;
901 EFI_HANDLE
*HandleList
;
905 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_OUTPUT_ALL_HEADER
), gShellDriver1HiiHandle
);
907 Name
= GetStringNameFromGuid (Guid
, NULL
);
909 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_OUTPUT_GUID_HEADER
), gShellDriver1HiiHandle
, Guid
);
911 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_OUTPUT_NAME_HEADER
), gShellDriver1HiiHandle
, Name
);
915 HandleList
= GetHandleListByProtocol(Guid
);
916 ShellStatus
= DoDhForHandleList(HandleList
, Verbose
, Sfo
, Language
, DriverInfo
);
917 SHELL_FREE_NON_NULL(HandleList
);
923 Function to determine use which method to print information.
924 If Protocol is NULL, The function will print all information.
926 @param[in] Protocol The pointer to the name or GUID of protocol or NULL.
927 @param[in] Verbose TRUE for extra info, FALSE otherwise.
928 @param[in] Sfo TRUE to output in standard format output (spec).
929 @param[in] Language Language string per UEFI specification.
930 @param[in] DriverInfo TRUE to show all info about the handle.
932 @retval SHELL_SUCCESS The operation was successful.
933 @retval SHELL_NOT_FOUND The protocol was not found.
934 @retval SHELL_INVALID_PARAMETER Protocol is invalid parameter.
938 IN CONST CHAR16
*Protocol
,
939 IN CONST BOOLEAN Verbose
,
940 IN CONST BOOLEAN Sfo
,
941 IN CONST CHAR8
*Language
,
942 IN CONST BOOLEAN DriverInfo
949 if (Protocol
== NULL
) {
950 return DoDhByProtocolGuid (NULL
, Verbose
, Sfo
, Language
, DriverInfo
);
952 Status
= ConvertStrToGuid (Protocol
, &Guid
);
953 if (!EFI_ERROR (Status
)) {
957 // Protocol is a Name, convert it to GUID
959 Status
= GetGuidFromStringName (Protocol
, Language
, &GuidPtr
);
960 if (EFI_ERROR(Status
)) {
961 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_NO_NAME_FOUND
), gShellDriver1HiiHandle
, Protocol
);
962 return (SHELL_NOT_FOUND
);
966 return DoDhByProtocolGuid (GuidPtr
, Verbose
, Sfo
, Language
, DriverInfo
);
971 Function to display decode information by Protocol.
972 The parameter Protocol is either a GUID or the name of protocol.
973 If the parameter Protocol is NULL, the function will print all
976 @param[in] Protocol The pointer to the name or GUID of protocol.
977 @param[in] Language Language string per UEFI specification.
979 @retval SHELL_SUCCESS The operation was successful.
980 @retval SHELL_OUT_OT_RESOURCES A memory allocation failed.
984 IN CONST CHAR16
*Protocol
,
985 IN CONST CHAR8
*Language
995 if (Protocol
== NULL
) {
997 Status
= GetAllMappingGuids (NULL
, &Counts
);
998 if (Status
== EFI_BUFFER_TOO_SMALL
) {
999 Guids
= AllocatePool (Counts
* sizeof(EFI_GUID
));
1000 if (Guids
== NULL
) {
1001 return SHELL_OUT_OF_RESOURCES
;
1004 Status
= GetAllMappingGuids (Guids
, &Counts
);
1005 if (Status
== EFI_SUCCESS
) {
1006 for (Index
= 0; Index
< Counts
; Index
++) {
1007 Name
= GetStringNameFromGuid (&Guids
[Index
], Language
);
1009 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_OUTPUT_DECODE
), gShellDriver1HiiHandle
, Name
, &Guids
[Index
]);
1011 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_NO_GUID_FOUND
), gShellDriver1HiiHandle
, &Guids
[Index
]);
1013 SHELL_FREE_NON_NULL (Name
);
1019 if (ConvertStrToGuid (Protocol
, &Guid
) == EFI_SUCCESS
) {
1020 Name
= GetStringNameFromGuid (&Guid
, Language
);
1022 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_OUTPUT_DECODE
), gShellDriver1HiiHandle
, Name
, &Guid
);
1024 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_NO_GUID_FOUND
), gShellDriver1HiiHandle
, &Guid
);
1026 SHELL_FREE_NON_NULL(Name
);
1028 Status
= GetGuidFromStringName (Protocol
, Language
, &Guids
);
1029 if (Status
== EFI_SUCCESS
) {
1030 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_OUTPUT_DECODE
), gShellDriver1HiiHandle
, Protocol
, Guids
);
1032 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_DH_NO_NAME_FOUND
), gShellDriver1HiiHandle
, Protocol
);
1037 return SHELL_SUCCESS
;
1041 Function for 'dh' command.
1043 @param[in] ImageHandle Handle to the Image (NULL if Internal).
1044 @param[in] SystemTable Pointer to the System Table (NULL if Internal).
1049 IN EFI_HANDLE ImageHandle
,
1050 IN EFI_SYSTEM_TABLE
*SystemTable
1054 LIST_ENTRY
*Package
;
1055 CHAR16
*ProblemParam
;
1056 SHELL_STATUS ShellStatus
;
1059 CONST CHAR16
*RawValue
;
1060 CONST CHAR16
*ProtocolVal
;
1063 BOOLEAN VerboseFlag
;
1064 UINT64 Intermediate
;
1067 ShellStatus
= SHELL_SUCCESS
;
1068 Status
= EFI_SUCCESS
;
1072 // initialize the shell lib (we must be in non-auto-init...)
1074 Status
= ShellInitialize();
1075 ASSERT_EFI_ERROR(Status
);
1077 Status
= CommandInit();
1078 ASSERT_EFI_ERROR(Status
);
1081 // parse the command line
1083 Status
= ShellCommandLineParse (ParamList
, &Package
, &ProblemParam
, TRUE
);
1084 if (EFI_ERROR(Status
)) {
1085 if (Status
== EFI_VOLUME_CORRUPTED
&& ProblemParam
!= NULL
) {
1086 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_GEN_PROBLEM
), gShellDriver1HiiHandle
, L
"dh", ProblemParam
);
1087 FreePool(ProblemParam
);
1088 ShellStatus
= SHELL_INVALID_PARAMETER
;
1093 if (ShellCommandLineGetCount(Package
) > 2) {
1094 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_GEN_TOO_MANY
), gShellDriver1HiiHandle
, L
"dh");
1095 ShellCommandLineFreeVarList (Package
);
1096 return (SHELL_INVALID_PARAMETER
);
1099 if (ShellCommandLineGetFlag(Package
, L
"-l")) {
1100 Lang
= ShellCommandLineGetValue(Package
, L
"-l");
1102 Language
= AllocateZeroPool(StrSize(Lang
));
1103 AsciiSPrint(Language
, StrSize(Lang
), "%S", Lang
);
1105 ASSERT(Language
== NULL
);
1106 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN(STR_GEN_NO_VALUE
), gShellDriver1HiiHandle
, L
"dh", L
"-l");
1107 ShellCommandLineFreeVarList(Package
);
1108 return (SHELL_INVALID_PARAMETER
);
1111 Language
= AllocateZeroPool(10);
1112 AsciiSPrint(Language
, 10, "en-us");
1115 SfoFlag
= ShellCommandLineGetFlag (Package
, L
"-sfo");
1116 DriverFlag
= ShellCommandLineGetFlag (Package
, L
"-d");
1117 VerboseFlag
= (BOOLEAN
)(ShellCommandLineGetFlag (Package
, L
"-v") || ShellCommandLineGetFlag (Package
, L
"-verbose"));
1118 RawValue
= ShellCommandLineGetRawValue (Package
, 1);
1119 ProtocolVal
= ShellCommandLineGetValue (Package
, L
"-p");
1121 if (RawValue
== NULL
) {
1122 if (ShellCommandLineGetFlag (Package
, L
"-p") && (ProtocolVal
== NULL
)) {
1123 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_GEN_NO_VALUE
), gShellDriver1HiiHandle
, L
"dh", L
"-p");
1124 ShellStatus
= SHELL_INVALID_PARAMETER
;
1127 // Print information by protocol, The ProtocolVal maybe is name or GUID or NULL.
1129 ShellStatus
= DoDhByProtocol (ProtocolVal
, VerboseFlag
, SfoFlag
, Language
, DriverFlag
);
1131 } else if ((RawValue
!= NULL
) &&
1132 (gUnicodeCollation
->StriColl(gUnicodeCollation
, L
"decode", (CHAR16
*) RawValue
) == 0)) {
1133 if (ShellCommandLineGetFlag (Package
, L
"-p") && (ProtocolVal
== NULL
)) {
1134 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_GEN_NO_VALUE
), gShellDriver1HiiHandle
, L
"dh", L
"-p");
1135 ShellStatus
= SHELL_INVALID_PARAMETER
;
1138 // Print decode informatino by protocol.
1140 ShellStatus
= DoDecodeByProtocol (ProtocolVal
, Language
);
1143 if (ShellCommandLineGetFlag (Package
, L
"-p")) {
1144 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_GEN_TOO_MANY
), gShellDriver1HiiHandle
, L
"dh");
1145 ShellStatus
= SHELL_INVALID_PARAMETER
;
1147 Status
= ShellConvertStringToUint64 (RawValue
, &Intermediate
, TRUE
, FALSE
);
1148 if (EFI_ERROR(Status
)) {
1149 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_GEN_INV_HANDLE
), gShellDriver1HiiHandle
, L
"dh", RawValue
);
1150 ShellStatus
= SHELL_INVALID_PARAMETER
;
1152 Handle
= ConvertHandleIndexToHandle ((UINTN
) Intermediate
);
1153 if (Handle
== NULL
) {
1154 ShellPrintHiiEx (-1, -1, NULL
, STRING_TOKEN (STR_GEN_INV_HANDLE
), gShellDriver1HiiHandle
, L
"dh", RawValue
);
1155 ShellStatus
= SHELL_INVALID_PARAMETER
;
1158 // Print information by handle.
1160 DoDhByHandle (Handle
, VerboseFlag
, SfoFlag
, Language
, DriverFlag
, FALSE
);
1166 ShellCommandLineFreeVarList (Package
);
1167 SHELL_FREE_NON_NULL(Language
);
1170 return (ShellStatus
);