/**
This function allows a program to extract the NV Image
that represents the default storage image
@param This A pointer to the EFI_HII_PROTOCOL instance.
@param Handle The HII handle from which will have default data retrieved.
UINTN - Mask used to retrieve the default image.
@param DefaultMask EDES_TODO: Add parameter description
@param VariablePackList Callee allocated, tightly-packed, link list data
structure that contain all default varaible packs
from the Hii Database.
@retval EFI_NOT_FOUND If Hii database does not contain any default images.
@retval EFI_INVALID_PARAMETER Invalid input parameter.
@retval EFI_SUCCESS Operation successful.
**/
EFI_STATUS
EFIAPI
HiiGetDefaultImage (
IN EFI_HII_PROTOCOL *This,
IN FRAMEWORK_EFI_HII_HANDLE Handle,
IN UINTN DefaultMask,
OUT EFI_HII_VARIABLE_PACK_LIST **VariablePackList
)
{
LIST_ENTRY *UefiDefaults;
EFI_STATUS Status;
HII_THUNK_PRIVATE_DATA *Private;
HII_THUNK_CONTEXT *ThunkContext;
Private = HII_THUNK_PRIVATE_DATA_FROM_THIS(This);
ThunkContext = FwHiiHandleToThunkContext (Private, Handle);
if (ThunkContext == NULL) {
ASSERT (FALSE);
return EFI_INVALID_PARAMETER;
}
UefiDefaults = NULL;
Status = UefiIfrGetBufferTypeDefaults (ThunkContext, &UefiDefaults);
if (EFI_ERROR (Status)) {
goto Done;
}
Status = UefiDefaultsToFwDefaults (UefiDefaults, DefaultMask, ThunkContext->FormSet->DefaultVarStoreId, VariablePackList);
Done:
FreeDefaultList (UefiDefaults);
return Status;
}
/**
Allows a program to determine the primary languages that are supported on a given handle.
This routine is intended to be used by drivers to query the interface database for supported languages.
This routine returns a string of concatenated 3-byte language identifiers, one per string package associated with the handle.
@param This A pointer to the EFI_HII_PROTOCOL instance.
@param Handle The handle on which the strings reside. Type EFI_HII_HANDLE is defined in EFI_HII_PROTOCOL.NewPack()
in the Packages section.
@param LanguageString A string allocated by GetPrimaryLanguages() that contains a list of all primary languages
registered on the handle. The routine will not return the three-spaces language identifier used in
other functions to indicate non-language-specific strings.
@retval EFI_SUCCESS LanguageString was correctly returned.
@retval EFI_INVALID_PARAMETER The Handle was unknown.
**/
EFI_STATUS
EFIAPI
HiiGetPrimaryLanguages (
IN EFI_HII_PROTOCOL *This,
IN FRAMEWORK_EFI_HII_HANDLE Handle,
OUT EFI_STRING *LanguageString
)
{
HII_THUNK_PRIVATE_DATA *Private;
EFI_HII_HANDLE UefiHiiHandle;
CHAR8 *LangCodes4646;
CHAR16 *UnicodeLangCodes639;
CHAR8 *LangCodes639;
EFI_STATUS Status;
Private = HII_THUNK_PRIVATE_DATA_FROM_THIS(This);
UefiHiiHandle = FwHiiHandleToUefiHiiHandle (Private, Handle);
if (UefiHiiHandle == NULL) {
return EFI_INVALID_PARAMETER;
}
LangCodes4646 = HiiGetSupportedLanguages (UefiHiiHandle);
if (LangCodes4646 == NULL) {
return EFI_INVALID_PARAMETER;
}
LangCodes639 = ConvertLanguagesRfc4646ToIso639 (LangCodes4646);
if (LangCodes639 == NULL) {
Status = EFI_INVALID_PARAMETER;
goto Done;
}
UnicodeLangCodes639 = AllocateZeroPool (AsciiStrSize (LangCodes639) * sizeof (CHAR16));
if (UnicodeLangCodes639 == NULL) {
Status = EFI_OUT_OF_RESOURCES;
goto Done;
}
//
// The language returned is in RFC 639-2 format.
//
AsciiStrToUnicodeStr (LangCodes639, UnicodeLangCodes639);
*LanguageString = UnicodeLangCodes639;
Status = EFI_SUCCESS;
Done:
FreePool (LangCodes4646);
if (LangCodes639 != NULL) {
FreePool (LangCodes639);
}
return Status;
}
/**
Determines the handles that are currently active in the database.
This function determines the handles that are currently active in the database.
For example, a program wishing to create a Setup-like configuration utility would use this call
to determine the handles that are available. It would then use calls defined in the forms section
below to extract forms and then interpret them.
@param This A pointer to the EFI_HII_PROTOCOL instance.
@param HandleBufferLength On input, a pointer to the length of the handle buffer.
On output, the length of the handle buffer that is required for the handles found.
@param Handle Pointer to an array of EFI_HII_HANDLE instances returned.
Type EFI_HII_HANDLE is defined in EFI_HII_PROTOCOL.NewPack() in the Packages section.
@retval EFI_SUCCESS Handle was updated successfully.
@retval EFI_BUFFER_TOO_SMALL The HandleBufferLength parameter indicates that Handle is too small
to support the number of handles. HandleBufferLength is updated with a value that
will enable the data to fit.
**/
EFI_STATUS
EFIAPI
HiiFindHandles (
IN EFI_HII_PROTOCOL *This,
IN OUT UINT16 *HandleBufferLength,
OUT FRAMEWORK_EFI_HII_HANDLE *Handle
)
{
UINT16 Count;
LIST_ENTRY *Link;
HII_THUNK_CONTEXT *ThunkContext;
HII_THUNK_PRIVATE_DATA *Private;
if (HandleBufferLength == NULL) {
return EFI_INVALID_PARAMETER;
}
Private = HII_THUNK_PRIVATE_DATA_FROM_THIS(This);
//
// Count the number of handles.
//
Count = 0;
Link = GetFirstNode (&Private->ThunkContextListHead);
while (!IsNull (&Private->ThunkContextListHead, Link)) {
Count++;
Link = GetNextNode (&Private->ThunkContextListHead, Link);
}
if (Count > *HandleBufferLength) {
*HandleBufferLength = (UINT16) (Count * sizeof (FRAMEWORK_EFI_HII_HANDLE));
return EFI_BUFFER_TOO_SMALL;
}
//
// Output the handles.
//
Count = 0;
Link = GetFirstNode (&Private->ThunkContextListHead);
while (!IsNull (&Private->ThunkContextListHead, Link)) {
ThunkContext = HII_THUNK_CONTEXT_FROM_LINK (Link);
Handle[Count] = ThunkContext->FwHiiHandle;
Count++;
Link = GetNextNode (&Private->ThunkContextListHead, Link);
}
*HandleBufferLength = (UINT16) (Count * sizeof (FRAMEWORK_EFI_HII_HANDLE));
return EFI_SUCCESS;
}
/**
Registers the various packages that are passed in a Package List.
@param This Pointer of Frameowk HII protocol instance.
@param Packages Pointer of HII packages.
@param Handle Handle value to be returned.
@retval EFI_SUCCESS Packages has added to HII database successfully.
@retval EFI_INVALID_PARAMETER If Handle or Packages is NULL.
**/
EFI_STATUS
EFIAPI
HiiNewPack (
IN EFI_HII_PROTOCOL *This,
IN EFI_HII_PACKAGES *Packages,
OUT FRAMEWORK_EFI_HII_HANDLE *Handle
)
{
EFI_STATUS Status;
HII_THUNK_PRIVATE_DATA *Private;
EFI_TPL OldTpl;
if (Handle == NULL) {
return EFI_INVALID_PARAMETER;
}
if (Packages == NULL) {
return EFI_INVALID_PARAMETER;
}
OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
//
// We use a simple Global variable to inform NewOrAddPackNotify()
// that the package list registered here is already registered
// in the HII Thunk Layer. So NewOrAddPackNotify () does not need to
// call registered the Package List again.
//
mInFrameworkHiiNewPack = TRUE;
Private = HII_THUNK_PRIVATE_DATA_FROM_THIS(This);
Status = UefiRegisterPackageList (
This,
Private,
Packages,
Handle
);
mInFrameworkHiiNewPack = FALSE;
gBS->RestoreTPL (OldTpl);
return Status;
}
/**
Remove a package from the HII database.
@param This Pointer of Frameowk HII protocol instance.
@param Handle Handle value to be removed.
@retval EFI_SUCCESS Packages has added to HII database successfully.
@retval EFI_INVALID_PARAMETER If Handle or Packages is NULL.
**/
EFI_STATUS
EFIAPI
HiiRemovePack (
IN EFI_HII_PROTOCOL *This,
IN FRAMEWORK_EFI_HII_HANDLE Handle
)
{
EFI_STATUS Status;
HII_THUNK_PRIVATE_DATA *Private;
HII_THUNK_CONTEXT *ThunkContext;
EFI_TPL OldTpl;
OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
mInFrameworkHiiRemovePack = TRUE;
Private = HII_THUNK_PRIVATE_DATA_FROM_THIS(This);
ThunkContext = FwHiiHandleToThunkContext (Private, Handle);
if (ThunkContext != NULL) {
Status = mHiiDatabase->RemovePackageList (
mHiiDatabase,
ThunkContext->UefiHiiHandle
);
ASSERT_EFI_ERROR (Status);
if (ThunkContext->IfrPackageCount != 0) {
UninstallDefaultConfigAccessProtocol (ThunkContext);
}
DestroyThunkContext (ThunkContext);
}else {
Status = EFI_NOT_FOUND;
}
mInFrameworkHiiRemovePack = FALSE;
gBS->RestoreTPL (OldTpl);
return Status;
}
/**
This function allows a program to extract a form or form package that has
previously been registered with the EFI HII database.
In this thunk module, this function will create a IFR Package with only
one Formset. Effectively, only the GUID of the Formset is updated and return
in this IFR package to caller. This is enable the Framework modules which call
a API named GetStringFromToken. GetStringFromToken retieves a String based on
a String Token from a Package List known only by the Formset GUID.
@param This A pointer to the EFI_HII_PROTOCOL instance.
@param Handle Handle on which the form resides. Type FRAMEWORK_EFI_HII_HANDLE is defined in
EFI_HII_PROTOCOL.NewPack() in the Packages section.
@param FormId Ignored by this implementation.
@param BufferLengthTemp On input, the size of input buffer. On output, it
is the size of FW_HII_FORMSET_TEMPLATE.
@param Buffer The buffer designed to receive the form(s).
@retval EFI_SUCCESS Buffer filled with the requested forms. BufferLength
was updated.
@retval EFI_INVALID_PARAMETER The handle is unknown.
@retval EFI_NOT_FOUND A form on the requested handle cannot be found with the
requested FormId.
@retval EFI_BUFFER_TOO_SMALL The buffer provided was not large enough to allow the form to be stored.
**/
EFI_STATUS
EFIAPI
HiiGetForms (
IN EFI_HII_PROTOCOL *This,
IN FRAMEWORK_EFI_HII_HANDLE Handle,
IN EFI_FORM_ID FormId,
IN OUT UINTN *BufferLengthTemp,
OUT UINT8 *Buffer
)
{
HII_THUNK_PRIVATE_DATA *Private;
HII_THUNK_CONTEXT *ThunkContext;
FW_HII_FORMSET_TEMPLATE *OutputFormSet;
if (*BufferLengthTemp < sizeof(FW_HII_FORMSET_TEMPLATE)) {
*BufferLengthTemp = sizeof(FW_HII_FORMSET_TEMPLATE);
return EFI_BUFFER_TOO_SMALL;
}
Private = HII_THUNK_PRIVATE_DATA_FROM_THIS(This);
ThunkContext = FwHiiHandleToThunkContext (Private, Handle);
if (ThunkContext == NULL) {
return EFI_NOT_FOUND;
}
OutputFormSet = (FW_HII_FORMSET_TEMPLATE *) Buffer;
CopyMem (OutputFormSet, &FormSetTemplate, sizeof (FW_HII_FORMSET_TEMPLATE));
CopyMem (&OutputFormSet->FormSet.Guid, &ThunkContext->TagGuid, sizeof (EFI_GUID));
if (ThunkContext->FormSet != NULL) {
OutputFormSet->FormSet.Class = ThunkContext->FormSet->Class;
OutputFormSet->FormSet.SubClass = ThunkContext->FormSet->SubClass;
OutputFormSet->FormSet.Help = ThunkContext->FormSet->Help;
OutputFormSet->FormSet.FormSetTitle = ThunkContext->FormSet->FormSetTitle;
}
return EFI_SUCCESS;
}
/**
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;
}
/**
Create or update a String Token in a String Package.
If *Reference == 0, a new String Token is created.
@param This A pointer to the EFI_HII_PROTOCOL instance.
@param Language Pointer to a NULL-terminated string containing a single ISO 639-2 language
identifier, indicating the language to print. A string consisting of
all spaces indicates that the string is applicable to all languages.
@param Handle The handle of the language pack to which the string is to be added.
@param Reference The string token assigned to the string.
@param NewString The string to be added.
@retval EFI_SUCCESS The string was effectively registered.
@retval EFI_INVALID_PARAMETER The Handle was unknown. The string is not created or updated in the
the string package.
**/
EFI_STATUS
EFIAPI
HiiNewString (
IN EFI_HII_PROTOCOL *This,
IN CHAR16 *Language,
IN FRAMEWORK_EFI_HII_HANDLE Handle,
IN OUT STRING_REF *Reference,
IN CHAR16 *NewString
)
{
EFI_STATUS Status;
HII_THUNK_PRIVATE_DATA *Private;
EFI_GUID TagGuid;
LIST_ENTRY *Link;
HII_THUNK_CONTEXT *ThunkContext;
HII_THUNK_CONTEXT *StringPackThunkContext;
EFI_STRING_ID StringId;
EFI_STRING_ID LastStringId;
CHAR8 AsciiLanguage[ISO_639_2_ENTRY_SIZE + 1];
CHAR16 LanguageCopy[ISO_639_2_ENTRY_SIZE + 1];
CHAR8 *Rfc4646AsciiLanguage;
LastStringId = (EFI_STRING_ID) 0;
StringId = (EFI_STRING_ID) 0;
Rfc4646AsciiLanguage = NULL;
if (Language != NULL) {
ZeroMem (AsciiLanguage, sizeof (AsciiLanguage));;
ZeroMem (LanguageCopy, sizeof (LanguageCopy));
CopyMem (LanguageCopy, Language, ISO_639_2_ENTRY_SIZE * sizeof (CHAR16));
UnicodeStrToAsciiStr (LanguageCopy, AsciiLanguage);
Rfc4646AsciiLanguage = ConvertLanguagesIso639ToRfc4646 (AsciiLanguage);
ASSERT (Rfc4646AsciiLanguage != NULL);
}
Private = HII_THUNK_PRIVATE_DATA_FROM_THIS(This);
StringPackThunkContext = FwHiiHandleToThunkContext (Private, Handle);
if (StringPackThunkContext == NULL) {
return EFI_INVALID_PARAMETER;
}
if (StringPackThunkContext->SharingStringPack) {
Status = GetTagGuidByFwHiiHandle (Private, Handle, &TagGuid);
ASSERT_EFI_ERROR (Status);
Link = GetFirstNode (&Private->ThunkContextListHead);
while (!IsNull (&Private->ThunkContextListHead, Link)) {
ThunkContext = HII_THUNK_CONTEXT_FROM_LINK (Link);
if (CompareGuid (&TagGuid, &ThunkContext->TagGuid)) {
if (ThunkContext->SharingStringPack) {
StringId = *Reference;
Status = UpdateString (ThunkContext, Rfc4646AsciiLanguage, NewString, &StringId);
if (EFI_ERROR (Status)) {
break;
}
DEBUG_CODE_BEGIN ();
if (*Reference == 0) {
//
// When creating new string token, make sure all created token is the same
// for all string packages registered using FW HII interface.
//
if (LastStringId == (EFI_STRING_ID) 0) {
LastStringId = StringId;
} else {
if (LastStringId != StringId) {
ASSERT(FALSE);
}
}
}
DEBUG_CODE_END ();
}
}
Link = GetNextNode (&Private->ThunkContextListHead, Link);
}
} else {
StringId = *Reference;
Status = UpdateString (StringPackThunkContext, Rfc4646AsciiLanguage, NewString, &StringId);
}
if (!EFI_ERROR (Status)) {
if (*Reference == 0) {
*Reference = StringId;
}
} else {
//
// Only EFI_INVALID_PARAMETER is defined in HII 0.92 specification.
//
Status = EFI_INVALID_PARAMETER;
}
return Status;
}
/**
Allows a program to determine which secondary languages are supported on a given handle for a given primary language
This routine is intended to be used by drivers to query the interface database for supported languages.
This routine returns a string of concatenated 3-byte language identifiers, one per string package associated with the handle.
@param This A pointer to the EFI_HII_PROTOCOL instance.
@param Handle The handle on which the strings reside. Type EFI_HII_HANDLE is defined in EFI_HII_PROTOCOL.NewPack()
in the Packages section.
@param PrimaryLanguage Pointer to a NULL-terminated string containing a single ISO 639-2 language identifier, indicating
the primary language.
@param LanguageString A string allocated by GetSecondaryLanguages() containing a list of all secondary languages registered
on the handle. The routine will not return the three-spaces language identifier used in other functions
to indicate non-language-specific strings, nor will it return the primary language. This function succeeds
but returns a NULL LanguageString if there are no secondary languages associated with the input Handle and
PrimaryLanguage pair. Type EFI_STRING is defined in String.
@retval EFI_SUCCESS LanguageString was correctly returned.
@retval EFI_INVALID_PARAMETER The Handle was unknown.
**/
EFI_STATUS
EFIAPI
HiiGetSecondaryLanguages (
IN EFI_HII_PROTOCOL *This,
IN FRAMEWORK_EFI_HII_HANDLE Handle,
IN CHAR16 *PrimaryLanguage,
OUT EFI_STRING *LanguageString
)
{
HII_THUNK_PRIVATE_DATA *Private;
EFI_HII_HANDLE UefiHiiHandle;
CHAR8 *PrimaryLang4646;
CHAR8 *PrimaryLang639;
CHAR8 *SecLangCodes4646;
CHAR8 *SecLangCodes639;
CHAR16 *UnicodeSecLangCodes639;
EFI_STATUS Status;
Private = HII_THUNK_PRIVATE_DATA_FROM_THIS(This);
SecLangCodes639 = NULL;
SecLangCodes4646 = NULL;
PrimaryLang4646 = NULL;
UnicodeSecLangCodes639 = NULL;
UefiHiiHandle = FwHiiHandleToUefiHiiHandle (Private, Handle);
if (UefiHiiHandle == NULL) {
return EFI_INVALID_PARAMETER;
}
PrimaryLang639 = AllocateZeroPool (StrLen (PrimaryLanguage) + 1);
if (PrimaryLang639 == NULL) {
Status = EFI_OUT_OF_RESOURCES;
goto Done;
}
UnicodeStrToAsciiStr (PrimaryLanguage, PrimaryLang639);
PrimaryLang4646 = ConvertLanguagesIso639ToRfc4646 (PrimaryLang639);
ASSERT_EFI_ERROR (PrimaryLang4646 != NULL);
SecLangCodes4646 = HiiGetSupportedSecondaryLanguages (UefiHiiHandle, PrimaryLang4646);
if (SecLangCodes4646 == NULL) {
Status = EFI_INVALID_PARAMETER;
goto Done;
}
SecLangCodes639 = ConvertLanguagesIso639ToRfc4646 (SecLangCodes4646);
if (SecLangCodes639 == NULL) {
Status = EFI_INVALID_PARAMETER;
goto Done;
}
UnicodeSecLangCodes639 = AllocateZeroPool (AsciiStrSize (SecLangCodes639) * sizeof (CHAR16));
if (UnicodeSecLangCodes639 == NULL) {
Status = EFI_OUT_OF_RESOURCES;
goto Done;
}
//
// The language returned is in RFC 4646 format.
//
*LanguageString = AsciiStrToUnicodeStr (SecLangCodes639, UnicodeSecLangCodes639);
Status = EFI_SUCCESS;
Done:
if (PrimaryLang639 != NULL) {
FreePool (PrimaryLang639);
}
if (SecLangCodes639 != NULL) {
FreePool (SecLangCodes639);
}
if (PrimaryLang4646 != NULL) {
FreePool (PrimaryLang4646);
}
if (SecLangCodes4646 != NULL) {
FreePool (SecLangCodes4646);
}
if (UnicodeSecLangCodes639 != NULL) {
FreePool (UnicodeSecLangCodes639);
}
return Status;
}
/**
This function allows the caller to update a form that has
previously been registered with the EFI HII database.
@param This EDES_TODO: Add parameter description
@param Handle Hii Handle associated with the Formset to modify
@param Label Update information starting immediately after this label in the IFR
@param AddData If TRUE, add data. If FALSE, remove data
@param Data If adding data, this is the pointer to the data to add
@retval EFI_SUCCESS Update success.
@retval Other Update fail.
**/
EFI_STATUS
EFIAPI
HiiThunkUpdateForm (
IN EFI_HII_PROTOCOL *This,
IN FRAMEWORK_EFI_HII_HANDLE Handle,
IN EFI_FORM_LABEL Label,
IN BOOLEAN AddData,
IN EFI_HII_UPDATE_DATA *Data
)
{
EFI_STATUS Status;
HII_THUNK_PRIVATE_DATA *Private;
HII_THUNK_CONTEXT *ThunkContext;
EFI_HII_HANDLE UefiHiiHandle;
EFI_GUID FormsetGuid;
EFI_FORM_ID FormId;
EFI_TPL OldTpl;
VOID *StartOpCodeHandle;
VOID *EndOpCodeHandle;
EFI_IFR_GUID_LABEL *StartLabel;
EFI_IFR_GUID_LABEL *EndLabel;
OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
mInFrameworkUpdatePakcage = TRUE;
Status = EFI_SUCCESS;
Private = HII_THUNK_PRIVATE_DATA_FROM_THIS(This);
ThunkContext = FwHiiHandleToThunkContext (Private, Handle);
if (ThunkContext == NULL) {
Status = EFI_NOT_FOUND;
goto Done;
}
if (Data->FormSetUpdate) {
Status = UpdateFormCallBack ((EFI_HANDLE) (UINTN) Data->FormCallbackHandle, ThunkContext);
if (EFI_ERROR (Status)) {
goto Done;
}
}
if (ThunkContext->IfrPackageCount == 0) {
ASSERT (FALSE);
Status = EFI_INVALID_PARAMETER;
goto Done;
} else {
UefiHiiHandle = ThunkContext->UefiHiiHandle;
}
Status = LocateFormId (UefiHiiHandle, Label, &FormsetGuid, &FormId);
if (EFI_ERROR (Status)) {
//
// Can't find the label.
//
goto Done;
}
//
// Init OpCode Handle
//
StartOpCodeHandle = HiiAllocateOpCodeHandle ();
ASSERT (StartOpCodeHandle != NULL);
EndOpCodeHandle = HiiAllocateOpCodeHandle ();
ASSERT (EndOpCodeHandle != NULL);
//
// Create Hii Extend Label OpCode as the start opcode
//
StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (StartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
StartLabel->Number = Label;
//
// Create Hii Extend Label OpCode as the end opcode
//
EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (EndOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
EndLabel->Number = 0xffff;
if (AddData) {
if (Data->DataCount != 0) {
ThunkContext = UefiHiiHandleToThunkContext (Private, UefiHiiHandle);
ASSERT (ThunkContext != NULL);
Status = FwUpdateDataToUefiUpdateData (ThunkContext, Data, StartOpCodeHandle);
ASSERT_EFI_ERROR (Status);
Status = HiiUpdateForm (UefiHiiHandle, &FormsetGuid, FormId, StartOpCodeHandle, NULL);
ASSERT_EFI_ERROR (Status);
}
} else {
//
// Delete Opcode starting from Labe in FormId found
//
Status = HiiUpdateForm (UefiHiiHandle, &FormsetGuid, FormId, StartOpCodeHandle, EndOpCodeHandle);
ASSERT_EFI_ERROR (Status);
}
HiiFreeOpCodeHandle (StartOpCodeHandle);
HiiFreeOpCodeHandle (EndOpCodeHandle);
Done:
mInFrameworkUpdatePakcage = FALSE;
gBS->RestoreTPL (OldTpl);
return Status;
}
