/**
Select the best matching language according to front page policy for best user experience.
This function supports both ISO 639-2 and RFC 4646 language codes, but language
code types may not be mixed in a single call to this function.
@param SupportedLanguages A pointer to a Null-terminated ASCII string that
contains a set of language codes in the format
specified by Iso639Language.
@param Iso639Language If TRUE, then all language codes are assumed to be
in ISO 639-2 format. If FALSE, then all language
codes are assumed to be in RFC 4646 language format.
@retval NULL The best matching language could not be found in SupportedLanguages.
@retval NULL There are not enough resources available to return the best matching
language.
@retval Other A pointer to a Null-terminated ASCII string that is the best matching
language in SupportedLanguages.
**/
CHAR8 *
DriverHealthManagerSelectBestLanguage (
IN CHAR8 *SupportedLanguages,
IN BOOLEAN Iso639Language
)
{
CHAR8 *LanguageVariable;
CHAR8 *BestLanguage;
GetEfiGlobalVariable2 (Iso639Language ? L"Lang" : L"PlatformLang", (VOID**)&LanguageVariable, NULL);
BestLanguage = GetBestLanguage(
SupportedLanguages,
Iso639Language,
(LanguageVariable != NULL) ? LanguageVariable : "",
Iso639Language ? "eng" : "en-US",
NULL
);
if (LanguageVariable != NULL) {
FreePool (LanguageVariable);
}
return BestLanguage;
}
/**
Worker function to initialize Unicode Collation support.
It tries to locate Unicode Collation (2) protocol and matches it with current
platform language code.
@param AgentHandle The handle used to open Unicode Collation (2) protocol.
@param ProtocolGuid The pointer to Unicode Collation (2) protocol GUID.
@param VariableName The name of the RFC 4646 or ISO 639-2 language variable.
@param DefaultLanguage The default language in case the RFC 4646 or ISO 639-2 language is absent.
@retval EFI_SUCCESS The Unicode Collation (2) protocol has been successfully located.
@retval Others The Unicode Collation (2) protocol has not been located.
**/
EFI_STATUS
InitializeUnicodeCollationSupportWorker (
IN EFI_HANDLE AgentHandle,
IN EFI_GUID *ProtocolGuid,
IN CONST CHAR16 *VariableName,
IN CONST CHAR8 *DefaultLanguage
)
{
EFI_STATUS ReturnStatus;
EFI_STATUS Status;
UINTN NumHandles;
UINTN Index;
EFI_HANDLE *Handles;
EFI_UNICODE_COLLATION_PROTOCOL *Uci;
BOOLEAN Iso639Language;
CHAR8 *Language;
CHAR8 *BestLanguage;
Status = gBS->LocateHandleBuffer (
ByProtocol,
ProtocolGuid,
NULL,
&NumHandles,
&Handles
);
if (EFI_ERROR (Status)) {
return Status;
}
Iso639Language = (BOOLEAN) (ProtocolGuid == &gEfiUnicodeCollationProtocolGuid);
GetEfiGlobalVariable2 (VariableName, (VOID**) &Language, NULL);
ReturnStatus = EFI_UNSUPPORTED;
for (Index = 0; Index < NumHandles; Index++) {
//
// Open Unicode Collation Protocol
//
Status = gBS->OpenProtocol (
Handles[Index],
ProtocolGuid,
(VOID **) &Uci,
AgentHandle,
NULL,
EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
if (EFI_ERROR (Status)) {
continue;
}
//
// Find the best matching matching language from the supported languages
// of Unicode Collation (2) protocol.
//
BestLanguage = GetBestLanguage (
Uci->SupportedLanguages,
Iso639Language,
(Language == NULL) ? "" : Language,
DefaultLanguage,
NULL
);
if (BestLanguage != NULL) {
FreePool (BestLanguage);
mUnicodeCollation = Uci;
ReturnStatus = EFI_SUCCESS;
break;
}
}
if (Language != NULL) {
FreePool (Language);
}
FreePool (Handles);
return ReturnStatus;
}
/**
This function extracts a string from a package already registered with the EFI HII database.
@param This A pointer to the EFI_HII_PROTOCOL instance.
@param Handle The HII handle on which the string resides.
@param Token The string token assigned to the string.
@param Raw If TRUE, the string is returned unedited in the internal storage format described
above. If false, the string returned is edited by replacing <cr> with <space>
and by removing special characters such as the <wide> prefix.
@param LanguageString Pointer to a NULL-terminated string containing a single ISO 639-2 language
identifier, indicating the language to print. If the LanguageString is empty (starts
with a NULL), the default system language will be used to determine the language.
@param BufferLength Length of the StringBuffer. If the status reports that the buffer width is too
small, this parameter is filled with the length of the buffer needed.
@param StringBuffer The buffer designed to receive the characters in the string. Type EFI_STRING is
defined in String.
@retval EFI_INVALID_PARAMETER If input parameter is invalid.
@retval EFI_BUFFER_TOO_SMALL If the *BufferLength is too small.
@retval EFI_SUCCESS Operation is successful.
**/
EFI_STATUS
EFIAPI
HiiThunkGetString (
IN EFI_HII_PROTOCOL *This,
IN FRAMEWORK_EFI_HII_HANDLE Handle,
IN STRING_REF Token,
IN BOOLEAN Raw,
IN CHAR16 *LanguageString,
IN OUT UINTN *BufferLength,
OUT EFI_STRING StringBuffer
)
{
HII_THUNK_PRIVATE_DATA *Private;
CHAR8 *Iso639AsciiLanguage;
CHAR8 *Rfc4646AsciiLanguage;
CHAR8 *SupportedLanguages;
CHAR8 *PlatformLanguage;
CHAR8 *BestLanguage;
EFI_HII_HANDLE UefiHiiHandle;
EFI_STATUS Status;
Private = HII_THUNK_PRIVATE_DATA_FROM_THIS(This);
Rfc4646AsciiLanguage = NULL;
SupportedLanguages = NULL;
PlatformLanguage = NULL;
Status = EFI_SUCCESS;
if (LanguageString != NULL) {
Iso639AsciiLanguage = AllocateZeroPool (StrLen (LanguageString) + 1);
if (Iso639AsciiLanguage == NULL) {
return EFI_OUT_OF_RESOURCES;
}
UnicodeStrToAsciiStr (LanguageString, Iso639AsciiLanguage);
//
// Caller of Framework HII Interface uses the Language Identification String defined
// in Iso639. So map it to the Language Identifier defined in RFC4646.
//
Rfc4646AsciiLanguage = ConvertLanguagesIso639ToRfc4646 (Iso639AsciiLanguage);
FreePool (Iso639AsciiLanguage);
//
// If Rfc4646AsciiLanguage is NULL, more language mapping must be added to
// Iso639ToRfc4646Map.
//
ASSERT (Rfc4646AsciiLanguage != NULL);
}
UefiHiiHandle = FwHiiHandleToUefiHiiHandle (Private, Handle);
if (UefiHiiHandle == NULL) {
Status = EFI_NOT_FOUND;
goto Done;
}
//
// Get the languages that the package specified by HiiHandle supports
//
SupportedLanguages = HiiGetSupportedLanguages (UefiHiiHandle);
if (SupportedLanguages == NULL) {
goto Done;
}
//
// Get the current platform language setting
//
PlatformLanguage = GetEfiGlobalVariable (L"PlatformLang");
//
// Get the best matching language from SupportedLanguages
//
BestLanguage = GetBestLanguage (
SupportedLanguages,
FALSE, // RFC 4646 mode
(Rfc4646AsciiLanguage != NULL) ? Rfc4646AsciiLanguage : "", // Highest priority
(PlatformLanguage != NULL) ? PlatformLanguage : "", // Next highest priority
SupportedLanguages, // Lowest priority
NULL
);
if (BestLanguage != NULL) {
Status = mHiiStringProtocol->GetString (
mHiiStringProtocol,
BestLanguage,
UefiHiiHandle,
Token,
StringBuffer,
BufferLength,
NULL
);
FreePool (BestLanguage);
} else {
Status = EFI_INVALID_PARAMETER;
}
Done:
if (Rfc4646AsciiLanguage != NULL) {
FreePool (Rfc4646AsciiLanguage);
}
if (SupportedLanguages != NULL) {
FreePool (SupportedLanguages);
}
if (PlatformLanguage != NULL) {
FreePool (PlatformLanguage);
}
return Status;
}
/**
Do the configuration in an environment without HII.
@param[in] Language The language code.
@param[in] ForceDefaults TRUE to force defaults, FALSE otherwise.
@param[in] DefaultType If ForceDefaults is TRUE, specifies the default type.
@param[in] AllChildren TRUE to configure all children, FALSE otherwise.
@param[in] ValidateOptions TRUE to validate existing options, FALSE otherwise.
@param[in] SetOptions TRUE to set options, FALSE otherwise.
@param[in] DriverImageHandle The handle for the driver to configure.
@param[in] DeviceHandle The handle of the device being managed by the Driver specified.
@param[in] ChildHandle The handle of a child device of the specified device.
@retval SHELL_NOT_FOUND A specified handle could not be found.
@retval SHELL_INVALID_PARAMETER A parameter has a invalid value.
**/
SHELL_STATUS
EFIAPI
PreHiiDrvCfg (
IN CONST CHAR8 *Language,
IN BOOLEAN ForceDefaults,
IN UINT32 DefaultType,
IN BOOLEAN AllChildren,
IN BOOLEAN ValidateOptions,
IN BOOLEAN SetOptions,
IN EFI_HANDLE DriverImageHandle,
IN EFI_HANDLE DeviceHandle,
IN EFI_HANDLE ChildHandle
)
{
EFI_STATUS Status;
SHELL_STATUS ShellStatus;
UINTN OuterLoopCounter;
CHAR8 *BestLanguage;
UINTN DriverImageHandleCount;
EFI_HANDLE *DriverImageHandleBuffer;
UINTN HandleCount;
EFI_HANDLE *HandleBuffer;
UINTN *HandleType;
UINTN LoopCounter;
UINTN ChildIndex;
UINTN ChildHandleCount;
EFI_HANDLE *ChildHandleBuffer;
UINTN *ChildHandleType;
EFI_DRIVER_CONFIGURATION_ACTION_REQUIRED ActionRequired;
EFI_DRIVER_CONFIGURATION_PROTOCOL *DriverConfiguration;
BOOLEAN Iso639Language;
UINTN HandleIndex1;
UINTN HandleIndex2;
UINTN HandleIndex3;
ShellStatus = SHELL_SUCCESS;
if (ChildHandle == NULL && AllChildren) {
SetOptions = FALSE;
}
if (ForceDefaults) {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DRVCFG_FORCE_D),
gShellDriver1HiiHandle,
DefaultType);
} else if (ValidateOptions) {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DRVCFG_VALIDATE),
gShellDriver1HiiHandle);
} else if (SetOptions) {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DRVCFG_SET),
gShellDriver1HiiHandle);
}
if (DriverImageHandle == 0) {
DriverImageHandleBuffer = GetHandleListByProtocolList(CfgGuidList);
if (DriverImageHandleBuffer == NULL) {
ShellStatus = SHELL_NOT_FOUND;
goto Done;
}
for (
HandleBuffer = DriverImageHandleBuffer, DriverImageHandleCount = 0
; HandleBuffer != NULL && *HandleBuffer != NULL
; HandleBuffer++,DriverImageHandleCount++);
} else {
DriverImageHandleCount = 1;
//
// Allocate buffer to hold the image handle so as to
// keep consistent with the above clause
//
DriverImageHandleBuffer = AllocatePool (sizeof (EFI_HANDLE));
ASSERT (DriverImageHandleBuffer);
DriverImageHandleBuffer[0] = DriverImageHandle;
}
for (OuterLoopCounter = 0; OuterLoopCounter < DriverImageHandleCount; OuterLoopCounter++) {
Iso639Language = FALSE;
Status = gBS->OpenProtocol (
DriverImageHandleBuffer[OuterLoopCounter],
&gEfiDriverConfiguration2ProtocolGuid,
(VOID **) &DriverConfiguration,
NULL,
NULL,
EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
if (EFI_ERROR (Status)) {
Iso639Language = TRUE;
Status = gBS->OpenProtocol (
DriverImageHandleBuffer[OuterLoopCounter],
&gEfiDriverConfigurationProtocolGuid,
(VOID **) &DriverConfiguration,
NULL,
NULL,
EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
}
if (EFI_ERROR (Status)) {
// ShellPrintHiiEx(
// -1,
// -1,
// NULL,
// STRING_TOKEN (STR_DRVCFG_NOT_SUPPORT),
// gShellDriver1HiiHandle,
// ConvertHandleToHandleIndex (DriverImageHandleBuffer[OuterLoopCounter])
// );
ShellStatus = SHELL_UNSUPPORTED;
continue;
}
BestLanguage = GetBestLanguage (
DriverConfiguration->SupportedLanguages,
Iso639Language,
Language!=NULL?Language:"",
DriverConfiguration->SupportedLanguages,
NULL
);
if (BestLanguage == NULL) {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_GEN_PROBLEM_VAL),
gShellDriver1HiiHandle,
L"-l"
);
ShellStatus = SHELL_INVALID_PARAMETER;
continue;
}
Status = ParseHandleDatabaseByRelationshipWithType (
DriverImageHandleBuffer[OuterLoopCounter],
NULL,
&HandleCount,
&HandleBuffer,
&HandleType
);
if (EFI_ERROR (Status)) {
continue;
}
if (SetOptions && DeviceHandle == NULL) {
gST->ConOut->ClearScreen (gST->ConOut);
Status = DriverConfiguration->SetOptions (
DriverConfiguration,
NULL,
NULL,
BestLanguage,
&ActionRequired
);
gST->ConOut->ClearScreen (gST->ConOut);
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DRVCFG_ALL_LANG),
gShellDriver1HiiHandle,
ConvertHandleToHandleIndex (DriverImageHandleBuffer[OuterLoopCounter]),
DriverConfiguration->SupportedLanguages
);
if (!EFI_ERROR (Status)) {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DRVCFG_OPTIONS_SET),
gShellDriver1HiiHandle);
for (LoopCounter = 0; LoopCounter < HandleCount; LoopCounter++) {
if ((HandleType[LoopCounter] & HR_CONTROLLER_HANDLE) == HR_CONTROLLER_HANDLE) {
ShellCmdDriverConfigurationProcessActionRequired (
DriverImageHandleBuffer[OuterLoopCounter],
HandleBuffer[LoopCounter],
NULL,
ActionRequired
);
}
}
} else {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DRVCFG_NOT_SET),
gShellDriver1HiiHandle,
Status);
}
continue;
}
for (LoopCounter = 0; LoopCounter < HandleCount; LoopCounter++) {
if ((HandleType[LoopCounter] & HR_CONTROLLER_HANDLE) != HR_CONTROLLER_HANDLE) {
continue;
}
if (DeviceHandle != NULL && DeviceHandle != HandleBuffer[LoopCounter]) {
continue;
}
if (ChildHandle == NULL) {
HandleIndex1 = ConvertHandleToHandleIndex (DriverImageHandleBuffer[OuterLoopCounter]);
HandleIndex2 = ConvertHandleToHandleIndex (HandleBuffer[LoopCounter]);
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DRVCFG_CTRL_LANG),
gShellDriver1HiiHandle,
HandleIndex1,
HandleIndex2,
DriverConfiguration->SupportedLanguages
);
if (ForceDefaults) {
Status = DriverConfiguration->ForceDefaults (
DriverConfiguration,
HandleBuffer[LoopCounter],
NULL,
DefaultType,
&ActionRequired
);
if (!EFI_ERROR (Status)) {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DRVCFG_DEF_FORCED),
gShellDriver1HiiHandle);
ShellCmdDriverConfigurationProcessActionRequired (
DriverImageHandleBuffer[OuterLoopCounter],
HandleBuffer[LoopCounter],
NULL,
ActionRequired
);
} else {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DRVCFG_FORCE_FAILED),
gShellDriver1HiiHandle,
Status);
ShellStatus = SHELL_DEVICE_ERROR;
}
} else if (ValidateOptions) {
Status = DriverConfiguration->OptionsValid (
DriverConfiguration,
HandleBuffer[LoopCounter],
NULL
);
if (!EFI_ERROR (Status)) {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DRVCFG_OPTIONS_VALID),
gShellDriver1HiiHandle);
} else {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DRVCFG_OPTIONS_INV),
gShellDriver1HiiHandle,
Status);
ShellStatus = SHELL_DEVICE_ERROR;
}
} else if (SetOptions) {
gST->ConOut->ClearScreen (gST->ConOut);
Status = DriverConfiguration->SetOptions (
DriverConfiguration,
HandleBuffer[LoopCounter],
NULL,
BestLanguage,
&ActionRequired
);
gST->ConOut->ClearScreen (gST->ConOut);
HandleIndex1 = ConvertHandleToHandleIndex (DriverImageHandleBuffer[OuterLoopCounter]);
HandleIndex2 = ConvertHandleToHandleIndex (HandleBuffer[LoopCounter]);
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DRVCFG_CTRL_LANG),
gShellDriver1HiiHandle,
HandleIndex1,
HandleIndex2,
DriverConfiguration->SupportedLanguages
);
if (!EFI_ERROR (Status)) {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DRVCFG_OPTIONS_SET),
gShellDriver1HiiHandle);
ShellCmdDriverConfigurationProcessActionRequired (
DriverImageHandleBuffer[OuterLoopCounter],
HandleBuffer[LoopCounter],
NULL,
ActionRequired
);
} else {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DRVCFG_NOT_SET),
gShellDriver1HiiHandle,
Status);
ShellStatus = SHELL_DEVICE_ERROR;
}
} else {
Print (L"\n");
}
}
if (ChildHandle == NULL && !AllChildren) {
continue;
}
Status = ParseHandleDatabaseByRelationshipWithType (
DriverImageHandleBuffer[OuterLoopCounter],
HandleBuffer[LoopCounter],
&ChildHandleCount,
&ChildHandleBuffer,
&ChildHandleType
);
if (EFI_ERROR (Status)) {
continue;
}
for (ChildIndex = 0; ChildIndex < ChildHandleCount; ChildIndex++) {
if ((ChildHandleType[ChildIndex] & HR_CHILD_HANDLE) != HR_CHILD_HANDLE) {
continue;
}
if (ChildHandle != NULL && ChildHandle != ChildHandleBuffer[ChildIndex]) {
continue;
}
HandleIndex1 = ConvertHandleToHandleIndex (DriverImageHandleBuffer[OuterLoopCounter]);
HandleIndex2 = ConvertHandleToHandleIndex (HandleBuffer[LoopCounter]);
HandleIndex3 = ConvertHandleToHandleIndex (ChildHandleBuffer[ChildIndex]);
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DRVCFG_CHILD_LANG),
gShellDriver1HiiHandle,
HandleIndex1,
HandleIndex2,
HandleIndex3,
DriverConfiguration->SupportedLanguages);
if (ForceDefaults) {
Status = DriverConfiguration->ForceDefaults (
DriverConfiguration,
HandleBuffer[LoopCounter],
ChildHandleBuffer[ChildIndex],
DefaultType,
&ActionRequired
);
if (!EFI_ERROR (Status)) {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DRVCFG_DEF_FORCED),
gShellDriver1HiiHandle);
ShellCmdDriverConfigurationProcessActionRequired (
DriverImageHandleBuffer[OuterLoopCounter],
HandleBuffer[LoopCounter],
ChildHandleBuffer[ChildIndex],
ActionRequired
);
} else {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DRVCFG_FORCE_FAILED),
gShellDriver1HiiHandle,
Status);
ShellStatus = SHELL_DEVICE_ERROR;
}
} else if (ValidateOptions) {
Status = DriverConfiguration->OptionsValid (
DriverConfiguration,
HandleBuffer[LoopCounter],
ChildHandleBuffer[ChildIndex]
);
if (!EFI_ERROR (Status)) {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DRVCFG_OPTIONS_VALID),
gShellDriver1HiiHandle);
} else {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DRVCFG_OPTIONS_INV),
gShellDriver1HiiHandle,
Status);
ShellStatus = SHELL_DEVICE_ERROR;
}
} else if (SetOptions) {
gST->ConOut->ClearScreen (gST->ConOut);
Status = DriverConfiguration->SetOptions (
DriverConfiguration,
HandleBuffer[LoopCounter],
ChildHandleBuffer[ChildIndex],
BestLanguage,
&ActionRequired
);
gST->ConOut->ClearScreen (gST->ConOut);
HandleIndex1 = ConvertHandleToHandleIndex (DriverImageHandleBuffer[OuterLoopCounter]);
HandleIndex2 = ConvertHandleToHandleIndex (HandleBuffer[LoopCounter]);
HandleIndex3 = ConvertHandleToHandleIndex (ChildHandleBuffer[ChildIndex]);
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DRVCFG_CHILD_LANG),
gShellDriver1HiiHandle,
HandleIndex1,
HandleIndex2,
HandleIndex3,
DriverConfiguration->SupportedLanguages
);
if (!EFI_ERROR (Status)) {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DRVCFG_OPTIONS_SET),
gShellDriver1HiiHandle);
ShellCmdDriverConfigurationProcessActionRequired (
DriverImageHandleBuffer[OuterLoopCounter],
HandleBuffer[LoopCounter],
ChildHandleBuffer[ChildIndex],
ActionRequired
);
} else {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DRVCFG_NOT_SET),
gShellDriver1HiiHandle,
Status);
ShellStatus = SHELL_DEVICE_ERROR;
}
} else {
Print (L"\n");
}
}
FreePool (ChildHandleBuffer);
FreePool (ChildHandleType);
}
FreePool (BestLanguage);
FreePool (HandleBuffer);
FreePool (HandleType);
}
if (DriverImageHandle != NULL && DriverImageHandleCount != 0) {
FreePool (DriverImageHandleBuffer);
}
Done:
return ShellStatus;
}
/*++
Check whether the language is supported for given HII handle
@param HiiHandle The HII package list handle.
@param Offset The offest of current lanague in the supported languages.
@param CurrentLang The language code.
@retval TRUE Supported.
@retval FALSE Not Supported.
--*/
BOOLEAN
EFIAPI
CurrentLanguageMatch (
IN EFI_HII_HANDLE HiiHandle,
OUT UINT16 *Offset,
OUT CHAR8 *CurrentLang
)
{
CHAR8 *DefaultLang;
CHAR8 *BestLanguage;
CHAR8 *Languages;
CHAR8 *MatchLang;
CHAR8 *EndMatchLang;
UINTN CompareLength;
BOOLEAN LangMatch;
Languages = HiiGetSupportedLanguages (HiiHandle);
if (Languages == NULL) {
return FALSE;
}
LangMatch = FALSE;
CurrentLang = GetEfiGlobalVariable (L"PlatformLang");
DefaultLang = (CHAR8 *) PcdGetPtr (PcdUefiVariableDefaultPlatformLang);
BestLanguage = GetBestLanguage (
Languages,
FALSE,
(CurrentLang != NULL) ? CurrentLang : "",
DefaultLang,
NULL
);
if (BestLanguage != NULL) {
//
// Find the best matching RFC 4646 language, compute the offset.
//
LangMatch = TRUE;
CompareLength = AsciiStrLen (BestLanguage);
for (MatchLang = Languages, (*Offset) = 0; *MatchLang != '\0'; (*Offset)++) {
//
// Seek to the end of current match language.
//
for (EndMatchLang = MatchLang; *EndMatchLang != '\0' && *EndMatchLang != ';'; EndMatchLang++);
if ((EndMatchLang == MatchLang + CompareLength) && AsciiStrnCmp(MatchLang, BestLanguage, CompareLength) == 0) {
//
// Find the current best Language in the supported languages
//
break;
}
//
// best language match be in the supported language.
//
ASSERT (*EndMatchLang == ';');
MatchLang = EndMatchLang + 1;
}
FreePool (BestLanguage);
}
FreePool (Languages);
if (CurrentLang != NULL) {
FreePool (CurrentLang);
}
return LangMatch;
}
/**
Get a human readable name for an image handle.
The following methods will be tried orderly:
1. Image PDB
2. ComponentName2 protocol
3. FFS UI section
4. Image GUID
5. Image DevicePath
6. Unknown Driver Name
@param[in] Handle
@post The resulting Unicode name string is stored in the
mGaugeString global array.
**/
VOID
GetNameFromHandle (
IN EFI_HANDLE Handle
)
{
EFI_STATUS Status;
EFI_LOADED_IMAGE_PROTOCOL *Image;
CHAR8 *PdbFileName;
EFI_DRIVER_BINDING_PROTOCOL *DriverBinding;
EFI_STRING StringPtr;
EFI_DEVICE_PATH_PROTOCOL *LoadedImageDevicePath;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
EFI_GUID *NameGuid;
CHAR16 *NameString;
UINTN StringSize;
CHAR8 *PlatformLanguage;
CHAR8 *BestLanguage;
EFI_COMPONENT_NAME2_PROTOCOL *ComponentName2;
BestLanguage = NULL;
PlatformLanguage = NULL;
//
// Method 1: Get the name string from image PDB
//
Status = gBS->HandleProtocol (
Handle,
&gEfiLoadedImageProtocolGuid,
(VOID **) &Image
);
if (EFI_ERROR (Status)) {
Status = gBS->OpenProtocol (
Handle,
&gEfiDriverBindingProtocolGuid,
(VOID **) &DriverBinding,
NULL,
NULL,
EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
if (!EFI_ERROR (Status)) {
Status = gBS->HandleProtocol (
DriverBinding->ImageHandle,
&gEfiLoadedImageProtocolGuid,
(VOID **) &Image
);
}
}
if (!EFI_ERROR (Status)) {
PdbFileName = PeCoffLoaderGetPdbPointer (Image->ImageBase);
if (PdbFileName != NULL) {
GetShortPdbFileName (PdbFileName, mGaugeString);
return;
}
}
//
// Method 2: Get the name string from ComponentName2 protocol
//
Status = gBS->HandleProtocol (
Handle,
&gEfiComponentName2ProtocolGuid,
(VOID **) &ComponentName2
);
if (!EFI_ERROR (Status)) {
//
// Get the current platform language setting
//
GetEfiGlobalVariable2 (L"PlatformLang", (VOID**)&PlatformLanguage, NULL);
BestLanguage = GetBestLanguage(
ComponentName2->SupportedLanguages,
FALSE,
PlatformLanguage,
ComponentName2->SupportedLanguages,
NULL
);
SafeFreePool (PlatformLanguage);
Status = ComponentName2->GetDriverName (
ComponentName2,
BestLanguage,
&StringPtr
);
SafeFreePool (BestLanguage);
if (!EFI_ERROR (Status)) {
StrnCpy (mGaugeString, StringPtr, DP_GAUGE_STRING_LENGTH);
mGaugeString[DP_GAUGE_STRING_LENGTH] = 0;
return;
}
}
Status = gBS->HandleProtocol (
Handle,
&gEfiLoadedImageDevicePathProtocolGuid,
(VOID **) &LoadedImageDevicePath
);
if (!EFI_ERROR (Status) && (LoadedImageDevicePath != NULL)) {
DevicePath = LoadedImageDevicePath;
//
// Try to get image GUID from LoadedImageDevicePath protocol
//
NameGuid = NULL;
while (!IsDevicePathEndType (DevicePath)) {
NameGuid = EfiGetNameGuidFromFwVolDevicePathNode ((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) DevicePath);
if (NameGuid != NULL) {
break;
}
DevicePath = NextDevicePathNode (DevicePath);
}
if (NameGuid != NULL) {
//
// Try to get the image's FFS UI section by image GUID
//
NameString = NULL;
StringSize = 0;
Status = GetSectionFromAnyFv (
NameGuid,
EFI_SECTION_USER_INTERFACE,
0,
(VOID **) &NameString,
&StringSize
);
if (!EFI_ERROR (Status)) {
//
// Method 3. Get the name string from FFS UI section
//
StrnCpy (mGaugeString, NameString, DP_GAUGE_STRING_LENGTH);
mGaugeString[DP_GAUGE_STRING_LENGTH] = 0;
FreePool (NameString);
} else {
//
// Method 4: Get the name string from image GUID
//
UnicodeSPrint (mGaugeString, sizeof (mGaugeString), L"%g", NameGuid);
}
return;
} else {
//
// Method 5: Get the name string from image DevicePath
//
NameString = ConvertDevicePathToText (LoadedImageDevicePath, TRUE, FALSE);
if (NameString != NULL) {
StrnCpy (mGaugeString, NameString, DP_GAUGE_STRING_LENGTH);
mGaugeString[DP_GAUGE_STRING_LENGTH] = 0;
FreePool (NameString);
return;
}
}
}
//
// Method 6: Unknown Driver Name
//
StringPtr = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_ERROR_NAME), NULL);
ASSERT (StringPtr != NULL);
StrCpy (mGaugeString, StringPtr);
FreePool (StringPtr);
return;
}
