You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1198 lines
36 KiB
1198 lines
36 KiB
4 years ago
|
/** @file
|
||
|
|
Main file for Dh shell Driver1 function.
|
||
|
|
|
||
|
|
(C) Copyright 2014-2015 Hewlett-Packard Development Company, L.P.<BR>
|
||
|
|
Copyright (c) 2010 - 2018, Intel Corporation. All rights reserved.<BR>
|
||
|
|
(C) Copyright 2017 Hewlett Packard Enterprise Development LP<BR>
|
||
|
|
This program and the accompanying materials
|
||
|
|
are licensed and made available under the terms and conditions of the BSD License
|
||
|
|
which accompanies this distribution. The full text of the license may be found at
|
||
|
|
http://opensource.org/licenses/bsd-license.php
|
||
|
|
|
||
|
|
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||
|
|
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||
|
|
|
||
|
|
**/
|
||
|
|
|
||
|
|
#include "UefiShellDriver1CommandsLib.h"
|
||
|
|
|
||
|
|
STATIC CONST SHELL_PARAM_ITEM ParamList[] = {
|
||
|
|
{L"-p", TypeValue},
|
||
|
|
{L"-d", TypeFlag},
|
||
|
|
{L"-v", TypeFlag},
|
||
|
|
{L"-verbose", TypeFlag},
|
||
|
|
{L"-sfo", TypeFlag},
|
||
|
|
{L"-l", TypeValue},
|
||
|
|
{NULL, TypeMax}
|
||
|
|
};
|
||
|
|
|
||
|
|
STATIC CONST EFI_GUID *UefiDriverModelProtocolsGuidArray[] = {
|
||
|
|
&gEfiDriverBindingProtocolGuid,
|
||
|
|
&gEfiPlatformDriverOverrideProtocolGuid,
|
||
|
|
&gEfiBusSpecificDriverOverrideProtocolGuid,
|
||
|
|
&gEfiDriverDiagnosticsProtocolGuid,
|
||
|
|
&gEfiDriverDiagnostics2ProtocolGuid,
|
||
|
|
&gEfiComponentNameProtocolGuid,
|
||
|
|
&gEfiComponentName2ProtocolGuid,
|
||
|
|
&gEfiPlatformToDriverConfigurationProtocolGuid,
|
||
|
|
&gEfiDriverSupportedEfiVersionProtocolGuid,
|
||
|
|
&gEfiDriverFamilyOverrideProtocolGuid,
|
||
|
|
&gEfiDriverHealthProtocolGuid,
|
||
|
|
&gEfiLoadedImageProtocolGuid,
|
||
|
|
NULL
|
||
|
|
};
|
||
|
|
|
||
|
|
UINTN mGuidDataLen[] = {8, 4, 4, 4, 12};
|
||
|
|
/**
|
||
|
|
Function to determine if the string can convert to a GUID.
|
||
|
|
The string must be restricted as "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" format.
|
||
|
|
|
||
|
|
@param[in] String The string to test.
|
||
|
|
|
||
|
|
@retval TRUE The string can convert to a GUID.
|
||
|
|
@retval FALSE The string can't convert to a GUID.
|
||
|
|
**/
|
||
|
|
BOOLEAN
|
||
|
|
IsValidGuidString(
|
||
|
|
IN CONST CHAR16 *String
|
||
|
|
)
|
||
|
|
{
|
||
|
|
CONST CHAR16 *Walker;
|
||
|
|
CONST CHAR16 *PrevWalker;
|
||
|
|
UINTN Index;
|
||
|
|
|
||
|
|
if (String == NULL) {
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
Walker = String;
|
||
|
|
PrevWalker = String;
|
||
|
|
Index = 0;
|
||
|
|
|
||
|
|
while (Walker != NULL && *Walker != CHAR_NULL) {
|
||
|
|
if ( (*Walker >= '0' && *Walker <= '9') ||
|
||
|
|
(*Walker >= 'a' && *Walker <= 'f') ||
|
||
|
|
(*Walker >= 'A' && *Walker <= 'F')
|
||
|
|
) {
|
||
|
|
Walker++;
|
||
|
|
} else {
|
||
|
|
if (*Walker == L'-' && (((UINTN)Walker - (UINTN)PrevWalker) / sizeof (CHAR16)) == mGuidDataLen[Index]) {
|
||
|
|
Walker++;
|
||
|
|
PrevWalker = Walker;
|
||
|
|
Index++;
|
||
|
|
} else {
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if ((((UINTN)Walker - (UINTN)PrevWalker) / sizeof (CHAR16)) == mGuidDataLen[Index]) {
|
||
|
|
return TRUE;
|
||
|
|
} else {
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
Convert a hex-character to decimal value.
|
||
|
|
|
||
|
|
This internal function only deal with Unicode character
|
||
|
|
which maps to a valid hexadecimal ASII character, i.e.
|
||
|
|
L'0' to L'9', L'a' to L'f' or L'A' to L'F'. For other
|
||
|
|
Unicode character, the value returned does not make sense.
|
||
|
|
|
||
|
|
@param[in] Char The character to convert.
|
||
|
|
|
||
|
|
@retval The numerical value converted.
|
||
|
|
**/
|
||
|
|
UINTN
|
||
|
|
HexCharToDecimal(
|
||
|
|
IN CHAR16 Char
|
||
|
|
)
|
||
|
|
{
|
||
|
|
if (Char >= '0' && Char <= '9') {
|
||
|
|
return Char - L'0';
|
||
|
|
} else if (Char >= 'a' && Char <= 'f') {
|
||
|
|
return Char - L'a' + 10;
|
||
|
|
} else {
|
||
|
|
return Char - L'A' + 10;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
Function try to convert a string to GUID format.
|
||
|
|
|
||
|
|
@param[in] String The string will be converted.
|
||
|
|
@param[out] Guid Save the result convert from string.
|
||
|
|
|
||
|
|
@retval EFI_SUCCESS The string was successfully converted to a GUID.
|
||
|
|
@retval EFI_UNSUPPORTED The input string is not in registry format.
|
||
|
|
**/
|
||
|
|
EFI_STATUS
|
||
|
|
ConvertStrToGuid(
|
||
|
|
IN CONST CHAR16 *String,
|
||
|
|
OUT GUID *Guid
|
||
|
|
)
|
||
|
|
{
|
||
|
|
CONST CHAR16 *Walker;
|
||
|
|
UINT8 TempValue;
|
||
|
|
UINTN Index;
|
||
|
|
|
||
|
|
if (String == NULL || !IsValidGuidString (String)) {
|
||
|
|
return EFI_UNSUPPORTED;
|
||
|
|
}
|
||
|
|
|
||
|
|
Index = 0;
|
||
|
|
|
||
|
|
Walker = String;
|
||
|
|
Guid->Data1 = (UINT32)StrHexToUint64 (Walker);
|
||
|
|
|
||
|
|
Walker += 9;
|
||
|
|
Guid->Data2 = (UINT16)StrHexToUint64 (Walker);
|
||
|
|
|
||
|
|
Walker += 5;
|
||
|
|
Guid->Data3 = (UINT16)StrHexToUint64 (Walker);
|
||
|
|
|
||
|
|
Walker += 5;
|
||
|
|
while (Walker != NULL && *Walker != CHAR_NULL) {
|
||
|
|
if (*Walker == L'-') {
|
||
|
|
Walker++;
|
||
|
|
} else {
|
||
|
|
TempValue = (UINT8)HexCharToDecimal (*Walker);
|
||
|
|
TempValue = (UINT8)LShiftU64 (TempValue, 4);
|
||
|
|
Walker++;
|
||
|
|
|
||
|
|
TempValue += (UINT8)HexCharToDecimal (*Walker);
|
||
|
|
Walker++;
|
||
|
|
|
||
|
|
Guid->Data4[Index] = TempValue;
|
||
|
|
Index++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return EFI_SUCCESS;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
Get the name of a driver by it's handle.
|
||
|
|
|
||
|
|
If a name is found the memory must be callee freed.
|
||
|
|
|
||
|
|
@param[in] TheHandle The driver's handle.
|
||
|
|
@param[in] Language The language to use.
|
||
|
|
@param[in] NameFound Upon a successful return the name found.
|
||
|
|
|
||
|
|
@retval EFI_SUCCESS The name was found.
|
||
|
|
**/
|
||
|
|
EFI_STATUS
|
||
|
|
GetDriverName (
|
||
|
|
IN EFI_HANDLE TheHandle,
|
||
|
|
IN CONST CHAR8 *Language,
|
||
|
|
IN CHAR16 **NameFound
|
||
|
|
)
|
||
|
|
{
|
||
|
|
CHAR8 *Lang;
|
||
|
|
EFI_STATUS Status;
|
||
|
|
EFI_COMPONENT_NAME2_PROTOCOL *CompName2;
|
||
|
|
CHAR16 *NameToReturn;
|
||
|
|
//
|
||
|
|
// Go through those handles until we get one that passes for GetComponentName
|
||
|
|
//
|
||
|
|
Status = gBS->OpenProtocol(
|
||
|
|
TheHandle,
|
||
|
|
&gEfiComponentName2ProtocolGuid,
|
||
|
|
(VOID**)&CompName2,
|
||
|
|
gImageHandle,
|
||
|
|
NULL,
|
||
|
|
EFI_OPEN_PROTOCOL_GET_PROTOCOL);
|
||
|
|
if (EFI_ERROR(Status)) {
|
||
|
|
Status = gBS->OpenProtocol(
|
||
|
|
TheHandle,
|
||
|
|
&gEfiComponentNameProtocolGuid,
|
||
|
|
(VOID**)&CompName2,
|
||
|
|
gImageHandle,
|
||
|
|
NULL,
|
||
|
|
EFI_OPEN_PROTOCOL_GET_PROTOCOL);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (EFI_ERROR(Status)) {
|
||
|
|
return (EFI_NOT_FOUND);
|
||
|
|
}
|
||
|
|
Lang = GetBestLanguageForDriver (CompName2->SupportedLanguages, Language, FALSE);
|
||
|
|
Status = CompName2->GetDriverName(CompName2, Lang, &NameToReturn);
|
||
|
|
FreePool(Lang);
|
||
|
|
|
||
|
|
if (!EFI_ERROR(Status) && NameToReturn != NULL) {
|
||
|
|
*NameFound = NULL;
|
||
|
|
StrnCatGrow(NameFound, NULL, NameToReturn, 0);
|
||
|
|
}
|
||
|
|
return (Status);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
Discover if a protocol guid is one of the UEFI Driver Model Protocols.
|
||
|
|
|
||
|
|
@param[in] Guid The guid to test.
|
||
|
|
|
||
|
|
@retval TRUE The guid does represent a driver model protocol.
|
||
|
|
@retval FALSE The guid does not represent a driver model protocol.
|
||
|
|
**/
|
||
|
|
BOOLEAN
|
||
|
|
IsDriverProt (
|
||
|
|
IN CONST EFI_GUID *Guid
|
||
|
|
)
|
||
|
|
{
|
||
|
|
CONST EFI_GUID **GuidWalker;
|
||
|
|
BOOLEAN GuidFound;
|
||
|
|
GuidFound = FALSE;
|
||
|
|
for (GuidWalker = UefiDriverModelProtocolsGuidArray
|
||
|
|
; GuidWalker != NULL && *GuidWalker != NULL
|
||
|
|
; GuidWalker++
|
||
|
|
){
|
||
|
|
if (CompareGuid(*GuidWalker, Guid)) {
|
||
|
|
GuidFound = TRUE;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return (GuidFound);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
Get information for a handle.
|
||
|
|
|
||
|
|
@param[in] TheHandle The handles to show info on.
|
||
|
|
@param[in] Language Language string per UEFI specification.
|
||
|
|
@param[in] Separator Separator string between information blocks.
|
||
|
|
@param[in] Verbose TRUE for extra info, FALSE otherwise.
|
||
|
|
@param[in] ExtraInfo TRUE for extra info, FALSE otherwise.
|
||
|
|
|
||
|
|
@retval SHELL_SUCCESS The operation was successful.
|
||
|
|
@retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
|
||
|
|
**/
|
||
|
|
CHAR16*
|
||
|
|
GetProtocolInfoString(
|
||
|
|
IN CONST EFI_HANDLE TheHandle,
|
||
|
|
IN CONST CHAR8 *Language,
|
||
|
|
IN CONST CHAR16 *Separator,
|
||
|
|
IN CONST BOOLEAN Verbose,
|
||
|
|
IN CONST BOOLEAN ExtraInfo
|
||
|
|
)
|
||
|
|
{
|
||
|
|
EFI_GUID **ProtocolGuidArray;
|
||
|
|
UINTN ArrayCount;
|
||
|
|
UINTN ProtocolIndex;
|
||
|
|
EFI_STATUS Status;
|
||
|
|
CHAR16 *RetVal;
|
||
|
|
UINTN Size;
|
||
|
|
CHAR16 *Temp;
|
||
|
|
CHAR16 GuidStr[40];
|
||
|
|
VOID *Instance;
|
||
|
|
CHAR16 InstanceStr[17];
|
||
|
|
|
||
|
|
ProtocolGuidArray = NULL;
|
||
|
|
RetVal = NULL;
|
||
|
|
Size = 0;
|
||
|
|
|
||
|
|
Status = gBS->ProtocolsPerHandle (
|
||
|
|
TheHandle,
|
||
|
|
&ProtocolGuidArray,
|
||
|
|
&ArrayCount
|
||
|
|
);
|
||
|
|
if (!EFI_ERROR (Status)) {
|
||
|
|
for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++) {
|
||
|
|
Temp = GetStringNameFromGuid(ProtocolGuidArray[ProtocolIndex], Language);
|
||
|
|
ASSERT((RetVal == NULL && Size == 0) || (RetVal != NULL));
|
||
|
|
if (Size != 0) {
|
||
|
|
StrnCatGrow(&RetVal, &Size, Separator, 0);
|
||
|
|
}
|
||
|
|
StrnCatGrow(&RetVal, &Size, L"%H", 0);
|
||
|
|
if (Temp == NULL) {
|
||
|
|
UnicodeSPrint (GuidStr, sizeof (GuidStr), L"%g", ProtocolGuidArray[ProtocolIndex]);
|
||
|
|
StrnCatGrow (&RetVal, &Size, GuidStr, 0);
|
||
|
|
} else {
|
||
|
|
StrnCatGrow(&RetVal, &Size, Temp, 0);
|
||
|
|
FreePool(Temp);
|
||
|
|
}
|
||
|
|
StrnCatGrow(&RetVal, &Size, L"%N", 0);
|
||
|
|
|
||
|
|
if(Verbose) {
|
||
|
|
Status = gBS->HandleProtocol (TheHandle, ProtocolGuidArray[ProtocolIndex], &Instance);
|
||
|
|
if (!EFI_ERROR (Status)) {
|
||
|
|
StrnCatGrow (&RetVal, &Size, L"(%H", 0);
|
||
|
|
UnicodeSPrint (InstanceStr, sizeof (InstanceStr), L"%x", Instance);
|
||
|
|
StrnCatGrow (&RetVal, &Size, InstanceStr, 0);
|
||
|
|
StrnCatGrow (&RetVal, &Size, L"%N)", 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ExtraInfo) {
|
||
|
|
Temp = GetProtocolInformationDump(TheHandle, ProtocolGuidArray[ProtocolIndex], Verbose);
|
||
|
|
if (Temp != NULL) {
|
||
|
|
ASSERT((RetVal == NULL && Size == 0) || (RetVal != NULL));
|
||
|
|
if (!Verbose) {
|
||
|
|
StrnCatGrow(&RetVal, &Size, L"(", 0);
|
||
|
|
StrnCatGrow(&RetVal, &Size, Temp, 0);
|
||
|
|
StrnCatGrow(&RetVal, &Size, L")", 0);
|
||
|
|
} else {
|
||
|
|
StrnCatGrow(&RetVal, &Size, Separator, 0);
|
||
|
|
StrnCatGrow(&RetVal, &Size, Temp, 0);
|
||
|
|
}
|
||
|
|
FreePool(Temp);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
SHELL_FREE_NON_NULL(ProtocolGuidArray);
|
||
|
|
|
||
|
|
if (RetVal == NULL) {
|
||
|
|
return (NULL);
|
||
|
|
}
|
||
|
|
|
||
|
|
ASSERT((RetVal == NULL && Size == 0) || (RetVal != NULL));
|
||
|
|
StrnCatGrow(&RetVal, &Size, Separator, 0);
|
||
|
|
return (RetVal);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
Gets the name of the loaded image.
|
||
|
|
|
||
|
|
@param[in] TheHandle The handle of the driver to get info on.
|
||
|
|
@param[out] Name The pointer to the pointer. Valid upon a successful return.
|
||
|
|
|
||
|
|
@retval EFI_SUCCESS The operation was successful.
|
||
|
|
**/
|
||
|
|
EFI_STATUS
|
||
|
|
GetDriverImageName (
|
||
|
|
IN EFI_HANDLE TheHandle,
|
||
|
|
OUT CHAR16 **Name
|
||
|
|
)
|
||
|
|
{
|
||
|
|
// get loaded image and devicepathtotext on image->Filepath
|
||
|
|
EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
|
||
|
|
EFI_STATUS Status;
|
||
|
|
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
|
||
|
|
|
||
|
|
if (TheHandle == NULL || Name == NULL) {
|
||
|
|
return (EFI_INVALID_PARAMETER);
|
||
|
|
}
|
||
|
|
|
||
|
|
Status = gBS->OpenProtocol (
|
||
|
|
TheHandle,
|
||
|
|
&gEfiLoadedImageProtocolGuid,
|
||
|
|
(VOID **) &LoadedImage,
|
||
|
|
gImageHandle,
|
||
|
|
NULL,
|
||
|
|
EFI_OPEN_PROTOCOL_GET_PROTOCOL
|
||
|
|
);
|
||
|
|
if (EFI_ERROR(Status)) {
|
||
|
|
return (Status);
|
||
|
|
}
|
||
|
|
DevicePath = LoadedImage->FilePath;
|
||
|
|
*Name = ConvertDevicePathToText(DevicePath, TRUE, TRUE);
|
||
|
|
return (EFI_SUCCESS);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
Display driver model information for a given handle.
|
||
|
|
|
||
|
|
@param[in] Handle The handle to display info on.
|
||
|
|
@param[in] BestName Use the best name?
|
||
|
|
@param[in] Language The language to output in.
|
||
|
|
**/
|
||
|
|
EFI_STATUS
|
||
|
|
DisplayDriverModelHandle (
|
||
|
|
IN EFI_HANDLE Handle,
|
||
|
|
IN BOOLEAN BestName,
|
||
|
|
IN CONST CHAR8 *Language OPTIONAL
|
||
|
|
)
|
||
|
|
{
|
||
|
|
EFI_STATUS Status;
|
||
|
|
BOOLEAN ConfigurationStatus;
|
||
|
|
BOOLEAN DiagnosticsStatus;
|
||
|
|
UINTN DriverBindingHandleCount;
|
||
|
|
EFI_HANDLE *DriverBindingHandleBuffer;
|
||
|
|
UINTN ParentControllerHandleCount;
|
||
|
|
EFI_HANDLE *ParentControllerHandleBuffer;
|
||
|
|
UINTN ChildControllerHandleCount;
|
||
|
|
EFI_HANDLE *ChildControllerHandleBuffer;
|
||
|
|
CHAR16 *TempStringPointer;
|
||
|
|
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
|
||
|
|
UINTN Index;
|
||
|
|
CHAR16 *DriverName;
|
||
|
|
EFI_DRIVER_BINDING_PROTOCOL *DriverBinding;
|
||
|
|
UINTN NumberOfChildren;
|
||
|
|
UINTN HandleIndex;
|
||
|
|
UINTN ControllerHandleCount;
|
||
|
|
EFI_HANDLE *ControllerHandleBuffer;
|
||
|
|
UINTN ChildIndex;
|
||
|
|
BOOLEAN Image;
|
||
|
|
|
||
|
|
DriverName = NULL;
|
||
|
|
|
||
|
|
//
|
||
|
|
// See if Handle is a device handle and display its details.
|
||
|
|
//
|
||
|
|
DriverBindingHandleBuffer = NULL;
|
||
|
|
Status = PARSE_HANDLE_DATABASE_UEFI_DRIVERS (
|
||
|
|
Handle,
|
||
|
|
&DriverBindingHandleCount,
|
||
|
|
&DriverBindingHandleBuffer
|
||
|
|
);
|
||
|
|
|
||
|
|
ParentControllerHandleBuffer = NULL;
|
||
|
|
Status = PARSE_HANDLE_DATABASE_PARENTS (
|
||
|
|
Handle,
|
||
|
|
&ParentControllerHandleCount,
|
||
|
|
&ParentControllerHandleBuffer
|
||
|
|
);
|
||
|
|
|
||
|
|
ChildControllerHandleBuffer = NULL;
|
||
|
|
Status = ParseHandleDatabaseForChildControllers (
|
||
|
|
Handle,
|
||
|
|
&ChildControllerHandleCount,
|
||
|
|
&ChildControllerHandleBuffer
|
||
|
|
);
|
||
|
|
|
||
|
|
DiagnosticsStatus = FALSE;
|
||
|
|
ConfigurationStatus = FALSE;
|
||
|
|
|
||
|
|
if (!EFI_ERROR(gBS->OpenProtocol(Handle, &gEfiDriverConfigurationProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
|
||
|
|
ConfigurationStatus = TRUE;
|
||
|
|
}
|
||
|
|
if (!EFI_ERROR(gBS->OpenProtocol(Handle, &gEfiDriverConfiguration2ProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
|
||
|
|
ConfigurationStatus = TRUE;
|
||
|
|
}
|
||
|
|
if (!EFI_ERROR(gBS->OpenProtocol(Handle, &gEfiDriverDiagnosticsProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
|
||
|
|
DiagnosticsStatus = TRUE;
|
||
|
|
}
|
||
|
|
if (!EFI_ERROR(gBS->OpenProtocol(Handle, &gEfiDriverDiagnostics2ProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
|
||
|
|
DiagnosticsStatus = TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
Status = EFI_SUCCESS;
|
||
|
|
|
||
|
|
if (DriverBindingHandleCount > 0 || ParentControllerHandleCount > 0 || ChildControllerHandleCount > 0) {
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
DevicePath = NULL;
|
||
|
|
TempStringPointer = NULL;
|
||
|
|
Status = gBS->HandleProtocol (Handle, &gEfiDevicePathProtocolGuid, (VOID**)&DevicePath);
|
||
|
|
|
||
|
|
Status = gEfiShellProtocol->GetDeviceName(Handle, EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
|
||
|
|
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_DRIVER1), gShellDriver1HiiHandle, TempStringPointer!=NULL?TempStringPointer:L"<Unknown>");
|
||
|
|
SHELL_FREE_NON_NULL(TempStringPointer);
|
||
|
|
|
||
|
|
TempStringPointer = ConvertDevicePathToText(DevicePath, TRUE, FALSE);
|
||
|
|
ShellPrintHiiEx(
|
||
|
|
-1,
|
||
|
|
-1,
|
||
|
|
NULL,
|
||
|
|
STRING_TOKEN (STR_DH_OUTPUT_DRIVER2),
|
||
|
|
gShellDriver1HiiHandle,
|
||
|
|
TempStringPointer!=NULL?TempStringPointer:L"<None>",
|
||
|
|
ParentControllerHandleCount == 0?L"ROOT":(ChildControllerHandleCount > 0)?L"BUS":L"DEVICE",
|
||
|
|
ConfigurationStatus?L"YES":L"NO",
|
||
|
|
DiagnosticsStatus?L"YES":L"NO"
|
||
|
|
);
|
||
|
|
|
||
|
|
SHELL_FREE_NON_NULL(TempStringPointer);
|
||
|
|
|
||
|
|
if (DriverBindingHandleCount == 0) {
|
||
|
|
ShellPrintHiiEx(
|
||
|
|
-1,
|
||
|
|
-1,
|
||
|
|
NULL,
|
||
|
|
STRING_TOKEN (STR_DH_OUTPUT_DRIVER3),
|
||
|
|
gShellDriver1HiiHandle,
|
||
|
|
L"<None>"
|
||
|
|
);
|
||
|
|
} else {
|
||
|
|
ShellPrintHiiEx(
|
||
|
|
-1,
|
||
|
|
-1,
|
||
|
|
NULL,
|
||
|
|
STRING_TOKEN (STR_DH_OUTPUT_DRIVER3),
|
||
|
|
gShellDriver1HiiHandle,
|
||
|
|
L""
|
||
|
|
);
|
||
|
|
for (Index = 0; Index < DriverBindingHandleCount; Index++) {
|
||
|
|
Image = FALSE;
|
||
|
|
Status = GetDriverName (
|
||
|
|
DriverBindingHandleBuffer[Index],
|
||
|
|
Language,
|
||
|
|
&DriverName
|
||
|
|
);
|
||
|
|
if (EFI_ERROR (Status)) {
|
||
|
|
Status = GetDriverImageName (
|
||
|
|
DriverBindingHandleBuffer[Index],
|
||
|
|
&DriverName
|
||
|
|
);
|
||
|
|
if (EFI_ERROR (Status)) {
|
||
|
|
DriverName = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (Image) {
|
||
|
|
ShellPrintHiiEx(
|
||
|
|
-1,
|
||
|
|
-1,
|
||
|
|
NULL,
|
||
|
|
STRING_TOKEN (STR_DH_OUTPUT_DRIVER4A),
|
||
|
|
gShellDriver1HiiHandle,
|
||
|
|
ConvertHandleToHandleIndex (DriverBindingHandleBuffer[Index]),
|
||
|
|
DriverName!=NULL?DriverName:L"<Unknown>"
|
||
|
|
);
|
||
|
|
} else {
|
||
|
|
ShellPrintHiiEx(
|
||
|
|
-1,
|
||
|
|
-1,
|
||
|
|
NULL,
|
||
|
|
STRING_TOKEN (STR_DH_OUTPUT_DRIVER4B),
|
||
|
|
gShellDriver1HiiHandle,
|
||
|
|
ConvertHandleToHandleIndex (DriverBindingHandleBuffer[Index]),
|
||
|
|
DriverName!=NULL?DriverName:L"<Unknown>"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
SHELL_FREE_NON_NULL(DriverName);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ParentControllerHandleCount == 0) {
|
||
|
|
ShellPrintHiiEx(
|
||
|
|
-1,
|
||
|
|
-1,
|
||
|
|
NULL,
|
||
|
|
STRING_TOKEN (STR_DH_OUTPUT_DRIVER5),
|
||
|
|
gShellDriver1HiiHandle,
|
||
|
|
L"<None>"
|
||
|
|
);
|
||
|
|
} else {
|
||
|
|
ShellPrintHiiEx(
|
||
|
|
-1,
|
||
|
|
-1,
|
||
|
|
NULL,
|
||
|
|
STRING_TOKEN (STR_DH_OUTPUT_DRIVER5),
|
||
|
|
gShellDriver1HiiHandle,
|
||
|
|
L""
|
||
|
|
);
|
||
|
|
for (Index = 0; Index < ParentControllerHandleCount; Index++) {
|
||
|
|
Status = gEfiShellProtocol->GetDeviceName(ParentControllerHandleBuffer[Index], EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
|
||
|
|
ShellPrintHiiEx(
|
||
|
|
-1,
|
||
|
|
-1,
|
||
|
|
NULL,
|
||
|
|
STRING_TOKEN (STR_DH_OUTPUT_DRIVER5B),
|
||
|
|
gShellDriver1HiiHandle,
|
||
|
|
ConvertHandleToHandleIndex (ParentControllerHandleBuffer[Index]),
|
||
|
|
TempStringPointer!=NULL?TempStringPointer:L"<Unknown>"
|
||
|
|
);
|
||
|
|
SHELL_FREE_NON_NULL(TempStringPointer);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ChildControllerHandleCount == 0) {
|
||
|
|
ShellPrintHiiEx(
|
||
|
|
-1,
|
||
|
|
-1,
|
||
|
|
NULL,
|
||
|
|
STRING_TOKEN (STR_DH_OUTPUT_DRIVER6),
|
||
|
|
gShellDriver1HiiHandle,
|
||
|
|
L"<None>"
|
||
|
|
);
|
||
|
|
} else {
|
||
|
|
ShellPrintHiiEx(
|
||
|
|
-1,
|
||
|
|
-1,
|
||
|
|
NULL,
|
||
|
|
STRING_TOKEN (STR_DH_OUTPUT_DRIVER6),
|
||
|
|
gShellDriver1HiiHandle,
|
||
|
|
L""
|
||
|
|
);
|
||
|
|
for (Index = 0; Index < ChildControllerHandleCount; Index++) {
|
||
|
|
Status = gEfiShellProtocol->GetDeviceName(ChildControllerHandleBuffer[Index], EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
|
||
|
|
ShellPrintHiiEx(
|
||
|
|
-1,
|
||
|
|
-1,
|
||
|
|
NULL,
|
||
|
|
STRING_TOKEN (STR_DH_OUTPUT_DRIVER6B),
|
||
|
|
gShellDriver1HiiHandle,
|
||
|
|
ConvertHandleToHandleIndex (ChildControllerHandleBuffer[Index]),
|
||
|
|
TempStringPointer!=NULL?TempStringPointer:L"<Unknown>"
|
||
|
|
);
|
||
|
|
SHELL_FREE_NON_NULL(TempStringPointer);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
SHELL_FREE_NON_NULL(DriverBindingHandleBuffer);
|
||
|
|
|
||
|
|
SHELL_FREE_NON_NULL(ParentControllerHandleBuffer);
|
||
|
|
|
||
|
|
SHELL_FREE_NON_NULL(ChildControllerHandleBuffer);
|
||
|
|
|
||
|
|
if (EFI_ERROR (Status)) {
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
//
|
||
|
|
// See if Handle is a driver binding handle and display its details.
|
||
|
|
//
|
||
|
|
Status = gBS->OpenProtocol (
|
||
|
|
Handle,
|
||
|
|
&gEfiDriverBindingProtocolGuid,
|
||
|
|
(VOID **) &DriverBinding,
|
||
|
|
NULL,
|
||
|
|
NULL,
|
||
|
|
EFI_OPEN_PROTOCOL_GET_PROTOCOL
|
||
|
|
);
|
||
|
|
if (EFI_ERROR (Status)) {
|
||
|
|
return EFI_SUCCESS;
|
||
|
|
}
|
||
|
|
|
||
|
|
NumberOfChildren = 0;
|
||
|
|
ControllerHandleBuffer = NULL;
|
||
|
|
Status = PARSE_HANDLE_DATABASE_DEVICES (
|
||
|
|
Handle,
|
||
|
|
&ControllerHandleCount,
|
||
|
|
&ControllerHandleBuffer
|
||
|
|
);
|
||
|
|
if (ControllerHandleCount > 0) {
|
||
|
|
for (HandleIndex = 0; HandleIndex < ControllerHandleCount; HandleIndex++) {
|
||
|
|
Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
|
||
|
|
Handle,
|
||
|
|
ControllerHandleBuffer[HandleIndex],
|
||
|
|
&ChildControllerHandleCount,
|
||
|
|
NULL
|
||
|
|
);
|
||
|
|
NumberOfChildren += ChildControllerHandleCount;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
Status = GetDriverName (Handle, Language, &DriverName);
|
||
|
|
if (EFI_ERROR (Status)) {
|
||
|
|
DriverName = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
ShellPrintHiiEx(
|
||
|
|
-1,
|
||
|
|
-1,
|
||
|
|
NULL,
|
||
|
|
STRING_TOKEN (STR_DH_OUTPUT_DRIVER7),
|
||
|
|
gShellDriver1HiiHandle,
|
||
|
|
ConvertHandleToHandleIndex(Handle),
|
||
|
|
DriverName!=NULL?DriverName:L"<Unknown>"
|
||
|
|
);
|
||
|
|
SHELL_FREE_NON_NULL(DriverName);
|
||
|
|
Status = GetDriverImageName (
|
||
|
|
Handle,
|
||
|
|
&DriverName
|
||
|
|
);
|
||
|
|
if (EFI_ERROR (Status)) {
|
||
|
|
DriverName = NULL;
|
||
|
|
}
|
||
|
|
ShellPrintHiiEx(
|
||
|
|
-1,
|
||
|
|
-1,
|
||
|
|
NULL,
|
||
|
|
STRING_TOKEN (STR_DH_OUTPUT_DRIVER7B),
|
||
|
|
gShellDriver1HiiHandle,
|
||
|
|
DriverName!=NULL?DriverName:L"<Unknown>"
|
||
|
|
);
|
||
|
|
SHELL_FREE_NON_NULL(DriverName);
|
||
|
|
|
||
|
|
ShellPrintHiiEx(
|
||
|
|
-1,
|
||
|
|
-1,
|
||
|
|
NULL,
|
||
|
|
STRING_TOKEN (STR_DH_OUTPUT_DRIVER8),
|
||
|
|
gShellDriver1HiiHandle,
|
||
|
|
DriverBinding->Version,
|
||
|
|
NumberOfChildren > 0?L"Bus":ControllerHandleCount > 0?L"Device":L"<Unknown>",
|
||
|
|
ConfigurationStatus?L"YES":L"NO",
|
||
|
|
DiagnosticsStatus?L"YES":L"NO"
|
||
|
|
);
|
||
|
|
|
||
|
|
if (ControllerHandleCount == 0) {
|
||
|
|
ShellPrintHiiEx(
|
||
|
|
-1,
|
||
|
|
-1,
|
||
|
|
NULL,
|
||
|
|
STRING_TOKEN (STR_DH_OUTPUT_DRIVER9),
|
||
|
|
gShellDriver1HiiHandle,
|
||
|
|
L"None"
|
||
|
|
);
|
||
|
|
} else {
|
||
|
|
ShellPrintHiiEx(
|
||
|
|
-1,
|
||
|
|
-1,
|
||
|
|
NULL,
|
||
|
|
STRING_TOKEN (STR_DH_OUTPUT_DRIVER9),
|
||
|
|
gShellDriver1HiiHandle,
|
||
|
|
L""
|
||
|
|
);
|
||
|
|
for (HandleIndex = 0; HandleIndex < ControllerHandleCount; HandleIndex++) {
|
||
|
|
Status = gEfiShellProtocol->GetDeviceName(ControllerHandleBuffer[HandleIndex], EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
|
||
|
|
|
||
|
|
ShellPrintHiiEx(
|
||
|
|
-1,
|
||
|
|
-1,
|
||
|
|
NULL,
|
||
|
|
STRING_TOKEN (STR_DH_OUTPUT_DRIVER9B),
|
||
|
|
gShellDriver1HiiHandle,
|
||
|
|
ConvertHandleToHandleIndex(ControllerHandleBuffer[HandleIndex]),
|
||
|
|
TempStringPointer!=NULL?TempStringPointer:L"<Unknown>"
|
||
|
|
);
|
||
|
|
SHELL_FREE_NON_NULL(TempStringPointer);
|
||
|
|
|
||
|
|
Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
|
||
|
|
Handle,
|
||
|
|
ControllerHandleBuffer[HandleIndex],
|
||
|
|
&ChildControllerHandleCount,
|
||
|
|
&ChildControllerHandleBuffer
|
||
|
|
);
|
||
|
|
if (!EFI_ERROR (Status)) {
|
||
|
|
for (ChildIndex = 0; ChildIndex < ChildControllerHandleCount; ChildIndex++) {
|
||
|
|
Status = gEfiShellProtocol->GetDeviceName(ChildControllerHandleBuffer[ChildIndex], EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
|
||
|
|
|
||
|
|
ShellPrintHiiEx(
|
||
|
|
-1,
|
||
|
|
-1,
|
||
|
|
NULL,
|
||
|
|
STRING_TOKEN (STR_DH_OUTPUT_DRIVER6C),
|
||
|
|
gShellDriver1HiiHandle,
|
||
|
|
ConvertHandleToHandleIndex(ChildControllerHandleBuffer[ChildIndex]),
|
||
|
|
TempStringPointer!=NULL?TempStringPointer:L"<Unknown>"
|
||
|
|
);
|
||
|
|
SHELL_FREE_NON_NULL(TempStringPointer);
|
||
|
|
}
|
||
|
|
|
||
|
|
SHELL_FREE_NON_NULL (ChildControllerHandleBuffer);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
SHELL_FREE_NON_NULL (ControllerHandleBuffer);
|
||
|
|
}
|
||
|
|
|
||
|
|
return EFI_SUCCESS;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
Display information for a handle.
|
||
|
|
|
||
|
|
@param[in] TheHandle The handles to show info on.
|
||
|
|
@param[in] Verbose TRUE for extra info, FALSE otherwise.
|
||
|
|
@param[in] Sfo TRUE to output in standard format output (spec).
|
||
|
|
@param[in] Language Language string per UEFI specification.
|
||
|
|
@param[in] DriverInfo TRUE to show all info about the handle.
|
||
|
|
@param[in] Multiple TRUE indicates more than will be output,
|
||
|
|
FALSE for a single one.
|
||
|
|
**/
|
||
|
|
VOID
|
||
|
|
DoDhByHandle(
|
||
|
|
IN CONST EFI_HANDLE TheHandle,
|
||
|
|
IN CONST BOOLEAN Verbose,
|
||
|
|
IN CONST BOOLEAN Sfo,
|
||
|
|
IN CONST CHAR8 *Language,
|
||
|
|
IN CONST BOOLEAN DriverInfo,
|
||
|
|
IN CONST BOOLEAN Multiple
|
||
|
|
)
|
||
|
|
{
|
||
|
|
CHAR16 *ProtocolInfoString;
|
||
|
|
|
||
|
|
ProtocolInfoString = NULL;
|
||
|
|
|
||
|
|
if (!Sfo) {
|
||
|
|
if (Multiple) {
|
||
|
|
ProtocolInfoString = GetProtocolInfoString(TheHandle, Language, L" ", Verbose, TRUE);
|
||
|
|
ShellPrintHiiEx(
|
||
|
|
-1,
|
||
|
|
-1,
|
||
|
|
NULL,
|
||
|
|
STRING_TOKEN (STR_DH_OUTPUT),
|
||
|
|
gShellDriver1HiiHandle,
|
||
|
|
ConvertHandleToHandleIndex(TheHandle),
|
||
|
|
ProtocolInfoString==NULL?L"":ProtocolInfoString
|
||
|
|
);
|
||
|
|
} else {
|
||
|
|
ProtocolInfoString = GetProtocolInfoString(TheHandle, Language, Verbose ? L"\r\n" : L" ", Verbose, TRUE);
|
||
|
|
if (Verbose) {
|
||
|
|
ShellPrintHiiEx(
|
||
|
|
-1,
|
||
|
|
-1,
|
||
|
|
NULL,
|
||
|
|
STRING_TOKEN (STR_DH_OUTPUT_SINGLE),
|
||
|
|
gShellDriver1HiiHandle,
|
||
|
|
ConvertHandleToHandleIndex(TheHandle),
|
||
|
|
TheHandle,
|
||
|
|
ProtocolInfoString==NULL?L"":ProtocolInfoString
|
||
|
|
);
|
||
|
|
} else {
|
||
|
|
ShellPrintHiiEx(
|
||
|
|
-1,
|
||
|
|
-1,
|
||
|
|
NULL,
|
||
|
|
STRING_TOKEN (STR_DH_OUTPUT_SINGLE_D),
|
||
|
|
gShellDriver1HiiHandle,
|
||
|
|
ConvertHandleToHandleIndex(TheHandle),
|
||
|
|
ProtocolInfoString==NULL?L"":ProtocolInfoString
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (DriverInfo) {
|
||
|
|
DisplayDriverModelHandle ((EFI_HANDLE)TheHandle, TRUE, Language);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
ProtocolInfoString = GetProtocolInfoString(TheHandle, Language, L";", FALSE, FALSE);
|
||
|
|
ShellPrintHiiEx(
|
||
|
|
-1,
|
||
|
|
-1,
|
||
|
|
NULL,
|
||
|
|
STRING_TOKEN (STR_DH_OUTPUT_SFO),
|
||
|
|
gShellDriver1HiiHandle,
|
||
|
|
Multiple ?L"HandlesInfo":L"HandleInfo",
|
||
|
|
L"DriverName",
|
||
|
|
L"ControllerName",
|
||
|
|
ConvertHandleToHandleIndex(TheHandle),
|
||
|
|
L"DevPath",
|
||
|
|
ProtocolInfoString==NULL?L"":ProtocolInfoString
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ProtocolInfoString != NULL) {
|
||
|
|
FreePool(ProtocolInfoString);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
Display information for all handles on a list.
|
||
|
|
|
||
|
|
@param[in] HandleList The NULL-terminated list of handles.
|
||
|
|
@param[in] Verbose TRUE for extra info, FALSE otherwise.
|
||
|
|
@param[in] Sfo TRUE to output in standard format output (spec).
|
||
|
|
@param[in] Language Language string per UEFI specification.
|
||
|
|
@param[in] DriverInfo TRUE to show all info about the handle.
|
||
|
|
|
||
|
|
@retval SHELL_SUCCESS The operation was successful.
|
||
|
|
@retval SHELL_ABORTED The operation was aborted.
|
||
|
|
**/
|
||
|
|
SHELL_STATUS
|
||
|
|
DoDhForHandleList(
|
||
|
|
IN CONST EFI_HANDLE *HandleList,
|
||
|
|
IN CONST BOOLEAN Verbose,
|
||
|
|
IN CONST BOOLEAN Sfo,
|
||
|
|
IN CONST CHAR8 *Language,
|
||
|
|
IN CONST BOOLEAN DriverInfo
|
||
|
|
)
|
||
|
|
{
|
||
|
|
CONST EFI_HANDLE *HandleWalker;
|
||
|
|
SHELL_STATUS ShellStatus;
|
||
|
|
|
||
|
|
ShellStatus = SHELL_SUCCESS;
|
||
|
|
for (HandleWalker = HandleList; HandleWalker != NULL && *HandleWalker != NULL; HandleWalker++) {
|
||
|
|
DoDhByHandle (*HandleWalker, Verbose, Sfo, Language, DriverInfo, TRUE);
|
||
|
|
if (ShellGetExecutionBreakFlag ()) {
|
||
|
|
ShellStatus = SHELL_ABORTED;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return (ShellStatus);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
Display information for a GUID of protocol.
|
||
|
|
|
||
|
|
@param[in] Guid The pointer to the name of the protocol.
|
||
|
|
@param[in] Verbose TRUE for extra info, FALSE otherwise.
|
||
|
|
@param[in] Sfo TRUE to output in standard format output (spec).
|
||
|
|
@param[in] Language Language string per UEFI specification.
|
||
|
|
@param[in] DriverInfo TRUE to show all info about the handle.
|
||
|
|
|
||
|
|
@retval SHELL_SUCCESS The operation was successful.
|
||
|
|
@retval SHELL_NOT_FOUND The GUID was not found.
|
||
|
|
@retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
|
||
|
|
**/
|
||
|
|
SHELL_STATUS
|
||
|
|
DoDhByProtocolGuid(
|
||
|
|
IN CONST GUID *Guid,
|
||
|
|
IN CONST BOOLEAN Verbose,
|
||
|
|
IN CONST BOOLEAN Sfo,
|
||
|
|
IN CONST CHAR8 *Language,
|
||
|
|
IN CONST BOOLEAN DriverInfo
|
||
|
|
)
|
||
|
|
{
|
||
|
|
CHAR16 *Name;
|
||
|
|
SHELL_STATUS ShellStatus;
|
||
|
|
EFI_HANDLE *HandleList;
|
||
|
|
|
||
|
|
if (!Sfo) {
|
||
|
|
if (Guid == NULL) {
|
||
|
|
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_ALL_HEADER), gShellDriver1HiiHandle);
|
||
|
|
} else {
|
||
|
|
Name = GetStringNameFromGuid (Guid, NULL);
|
||
|
|
if (Name == NULL) {
|
||
|
|
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_GUID_HEADER), gShellDriver1HiiHandle, Guid);
|
||
|
|
} else {
|
||
|
|
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_NAME_HEADER), gShellDriver1HiiHandle, Name);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
HandleList = GetHandleListByProtocol(Guid);
|
||
|
|
ShellStatus = DoDhForHandleList(HandleList, Verbose, Sfo, Language, DriverInfo);
|
||
|
|
SHELL_FREE_NON_NULL(HandleList);
|
||
|
|
|
||
|
|
return ShellStatus;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
Function to determine use which method to print information.
|
||
|
|
If Protocol is NULL, The function will print all information.
|
||
|
|
|
||
|
|
@param[in] Protocol The pointer to the name or GUID of protocol or NULL.
|
||
|
|
@param[in] Verbose TRUE for extra info, FALSE otherwise.
|
||
|
|
@param[in] Sfo TRUE to output in standard format output (spec).
|
||
|
|
@param[in] Language Language string per UEFI specification.
|
||
|
|
@param[in] DriverInfo TRUE to show all info about the handle.
|
||
|
|
|
||
|
|
@retval SHELL_SUCCESS The operation was successful.
|
||
|
|
@retval SHELL_NOT_FOUND The protocol was not found.
|
||
|
|
@retval SHELL_INVALID_PARAMETER Protocol is invalid parameter.
|
||
|
|
**/
|
||
|
|
SHELL_STATUS
|
||
|
|
DoDhByProtocol (
|
||
|
|
IN CONST CHAR16 *Protocol,
|
||
|
|
IN CONST BOOLEAN Verbose,
|
||
|
|
IN CONST BOOLEAN Sfo,
|
||
|
|
IN CONST CHAR8 *Language,
|
||
|
|
IN CONST BOOLEAN DriverInfo
|
||
|
|
)
|
||
|
|
{
|
||
|
|
EFI_GUID Guid;
|
||
|
|
EFI_GUID *GuidPtr;
|
||
|
|
EFI_STATUS Status;
|
||
|
|
|
||
|
|
if (Protocol == NULL) {
|
||
|
|
return DoDhByProtocolGuid (NULL, Verbose, Sfo, Language, DriverInfo);
|
||
|
|
} else {
|
||
|
|
Status = ConvertStrToGuid (Protocol, &Guid);
|
||
|
|
if (!EFI_ERROR (Status)) {
|
||
|
|
GuidPtr = &Guid;
|
||
|
|
} else {
|
||
|
|
//
|
||
|
|
// Protocol is a Name, convert it to GUID
|
||
|
|
//
|
||
|
|
Status = GetGuidFromStringName (Protocol, Language, &GuidPtr);
|
||
|
|
if (EFI_ERROR(Status)) {
|
||
|
|
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_NO_NAME_FOUND), gShellDriver1HiiHandle, Protocol);
|
||
|
|
return (SHELL_NOT_FOUND);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return DoDhByProtocolGuid (GuidPtr, Verbose, Sfo, Language, DriverInfo);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
Function to display decode information by Protocol.
|
||
|
|
The parameter Protocol is either a GUID or the name of protocol.
|
||
|
|
If the parameter Protocol is NULL, the function will print all
|
||
|
|
decode information.
|
||
|
|
|
||
|
|
@param[in] Protocol The pointer to the name or GUID of protocol.
|
||
|
|
@param[in] Language Language string per UEFI specification.
|
||
|
|
|
||
|
|
@retval SHELL_SUCCESS The operation was successful.
|
||
|
|
@retval SHELL_OUT_OT_RESOURCES A memory allocation failed.
|
||
|
|
**/
|
||
|
|
SHELL_STATUS
|
||
|
|
DoDecodeByProtocol(
|
||
|
|
IN CONST CHAR16 *Protocol,
|
||
|
|
IN CONST CHAR8 *Language
|
||
|
|
)
|
||
|
|
{
|
||
|
|
EFI_STATUS Status;
|
||
|
|
EFI_GUID *Guids;
|
||
|
|
EFI_GUID Guid;
|
||
|
|
UINTN Counts;
|
||
|
|
UINTN Index;
|
||
|
|
CHAR16 *Name;
|
||
|
|
|
||
|
|
if (Protocol == NULL) {
|
||
|
|
Counts = 0;
|
||
|
|
Status = GetAllMappingGuids (NULL, &Counts);
|
||
|
|
if (Status == EFI_BUFFER_TOO_SMALL) {
|
||
|
|
Guids = AllocatePool (Counts * sizeof(EFI_GUID));
|
||
|
|
if (Guids == NULL) {
|
||
|
|
return SHELL_OUT_OF_RESOURCES;
|
||
|
|
}
|
||
|
|
|
||
|
|
Status = GetAllMappingGuids (Guids, &Counts);
|
||
|
|
if (Status == EFI_SUCCESS) {
|
||
|
|
for (Index = 0; Index < Counts; Index++) {
|
||
|
|
Name = GetStringNameFromGuid (&Guids[Index], Language);
|
||
|
|
if (Name != NULL) {
|
||
|
|
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_DECODE), gShellDriver1HiiHandle, Name, &Guids[Index]);
|
||
|
|
} else {
|
||
|
|
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_NO_GUID_FOUND), gShellDriver1HiiHandle, &Guids[Index]);
|
||
|
|
}
|
||
|
|
SHELL_FREE_NON_NULL (Name);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
FreePool (Guids);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (ConvertStrToGuid (Protocol, &Guid) == EFI_SUCCESS) {
|
||
|
|
Name = GetStringNameFromGuid (&Guid, Language);
|
||
|
|
if (Name != NULL) {
|
||
|
|
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_DECODE), gShellDriver1HiiHandle, Name, &Guid);
|
||
|
|
} else {
|
||
|
|
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_NO_GUID_FOUND), gShellDriver1HiiHandle, &Guid);
|
||
|
|
}
|
||
|
|
SHELL_FREE_NON_NULL(Name);
|
||
|
|
} else {
|
||
|
|
Status = GetGuidFromStringName (Protocol, Language, &Guids);
|
||
|
|
if (Status == EFI_SUCCESS) {
|
||
|
|
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_DECODE), gShellDriver1HiiHandle, Protocol, Guids);
|
||
|
|
} else {
|
||
|
|
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_NO_NAME_FOUND), gShellDriver1HiiHandle, Protocol);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return SHELL_SUCCESS;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
Function for 'dh' command.
|
||
|
|
|
||
|
|
@param[in] ImageHandle Handle to the Image (NULL if Internal).
|
||
|
|
@param[in] SystemTable Pointer to the System Table (NULL if Internal).
|
||
|
|
**/
|
||
|
|
SHELL_STATUS
|
||
|
|
EFIAPI
|
||
|
|
ShellCommandRunDh (
|
||
|
|
IN EFI_HANDLE ImageHandle,
|
||
|
|
IN EFI_SYSTEM_TABLE *SystemTable
|
||
|
|
)
|
||
|
|
{
|
||
|
|
EFI_STATUS Status;
|
||
|
|
LIST_ENTRY *Package;
|
||
|
|
CHAR16 *ProblemParam;
|
||
|
|
SHELL_STATUS ShellStatus;
|
||
|
|
CHAR8 *Language;
|
||
|
|
CONST CHAR16 *Lang;
|
||
|
|
CONST CHAR16 *RawValue;
|
||
|
|
CONST CHAR16 *ProtocolVal;
|
||
|
|
BOOLEAN SfoFlag;
|
||
|
|
BOOLEAN DriverFlag;
|
||
|
|
BOOLEAN VerboseFlag;
|
||
|
|
UINT64 Intermediate;
|
||
|
|
EFI_HANDLE Handle;
|
||
|
|
|
||
|
|
ShellStatus = SHELL_SUCCESS;
|
||
|
|
Status = EFI_SUCCESS;
|
||
|
|
Language = NULL;
|
||
|
|
|
||
|
|
//
|
||
|
|
// initialize the shell lib (we must be in non-auto-init...)
|
||
|
|
//
|
||
|
|
Status = ShellInitialize();
|
||
|
|
ASSERT_EFI_ERROR(Status);
|
||
|
|
|
||
|
|
Status = CommandInit();
|
||
|
|
ASSERT_EFI_ERROR(Status);
|
||
|
|
|
||
|
|
//
|
||
|
|
// parse the command line
|
||
|
|
//
|
||
|
|
Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);
|
||
|
|
if (EFI_ERROR(Status)) {
|
||
|
|
if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {
|
||
|
|
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDriver1HiiHandle, L"dh", ProblemParam);
|
||
|
|
FreePool(ProblemParam);
|
||
|
|
ShellStatus = SHELL_INVALID_PARAMETER;
|
||
|
|
} else {
|
||
|
|
ASSERT(FALSE);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (ShellCommandLineGetCount(Package) > 2) {
|
||
|
|
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle, L"dh");
|
||
|
|
ShellCommandLineFreeVarList (Package);
|
||
|
|
return (SHELL_INVALID_PARAMETER);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ShellCommandLineGetFlag(Package, L"-l")) {
|
||
|
|
Lang = ShellCommandLineGetValue(Package, L"-l");
|
||
|
|
if (Lang != NULL) {
|
||
|
|
Language = AllocateZeroPool(StrSize(Lang));
|
||
|
|
AsciiSPrint(Language, StrSize(Lang), "%S", Lang);
|
||
|
|
} else {
|
||
|
|
ASSERT(Language == NULL);
|
||
|
|
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN(STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"dh", L"-l");
|
||
|
|
ShellCommandLineFreeVarList(Package);
|
||
|
|
return (SHELL_INVALID_PARAMETER);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
Language = AllocateZeroPool(10);
|
||
|
|
AsciiSPrint(Language, 10, "en-us");
|
||
|
|
}
|
||
|
|
|
||
|
|
SfoFlag = ShellCommandLineGetFlag (Package, L"-sfo");
|
||
|
|
DriverFlag = ShellCommandLineGetFlag (Package, L"-d");
|
||
|
|
VerboseFlag = (BOOLEAN)(ShellCommandLineGetFlag (Package, L"-v") || ShellCommandLineGetFlag (Package, L"-verbose"));
|
||
|
|
RawValue = ShellCommandLineGetRawValue (Package, 1);
|
||
|
|
ProtocolVal = ShellCommandLineGetValue (Package, L"-p");
|
||
|
|
|
||
|
|
if (RawValue == NULL) {
|
||
|
|
if (ShellCommandLineGetFlag (Package, L"-p") && (ProtocolVal == NULL)) {
|
||
|
|
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"dh", L"-p");
|
||
|
|
ShellStatus = SHELL_INVALID_PARAMETER;
|
||
|
|
} else {
|
||
|
|
//
|
||
|
|
// Print information by protocol, The ProtocolVal maybe is name or GUID or NULL.
|
||
|
|
//
|
||
|
|
ShellStatus = DoDhByProtocol (ProtocolVal, VerboseFlag, SfoFlag, Language, DriverFlag);
|
||
|
|
}
|
||
|
|
} else if ((RawValue != NULL) &&
|
||
|
|
(gUnicodeCollation->StriColl(gUnicodeCollation, L"decode", (CHAR16 *) RawValue) == 0)) {
|
||
|
|
if (ShellCommandLineGetFlag (Package, L"-p") && (ProtocolVal == NULL)) {
|
||
|
|
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"dh", L"-p");
|
||
|
|
ShellStatus = SHELL_INVALID_PARAMETER;
|
||
|
|
} else {
|
||
|
|
//
|
||
|
|
// Print decode informatino by protocol.
|
||
|
|
//
|
||
|
|
ShellStatus = DoDecodeByProtocol (ProtocolVal, Language);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (ShellCommandLineGetFlag (Package, L"-p")) {
|
||
|
|
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle, L"dh");
|
||
|
|
ShellStatus = SHELL_INVALID_PARAMETER;
|
||
|
|
} else {
|
||
|
|
Status = ShellConvertStringToUint64 (RawValue, &Intermediate, TRUE, FALSE);
|
||
|
|
if (EFI_ERROR(Status)) {
|
||
|
|
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, L"dh", RawValue);
|
||
|
|
ShellStatus = SHELL_INVALID_PARAMETER;
|
||
|
|
} else {
|
||
|
|
Handle = ConvertHandleIndexToHandle ((UINTN) Intermediate);
|
||
|
|
if (Handle == NULL) {
|
||
|
|
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, L"dh", RawValue);
|
||
|
|
ShellStatus = SHELL_INVALID_PARAMETER;
|
||
|
|
} else {
|
||
|
|
//
|
||
|
|
// Print information by handle.
|
||
|
|
//
|
||
|
|
DoDhByHandle (Handle, VerboseFlag, SfoFlag, Language, DriverFlag, FALSE);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ShellCommandLineFreeVarList (Package);
|
||
|
|
SHELL_FREE_NON_NULL(Language);
|
||
|
|
}
|
||
|
|
|
||
|
|
return (ShellStatus);
|
||
|
|
}
|