/** 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; }
/** Find the corressponding UEFI HII Handle from a Framework HII Handle given. @param Private The HII Thunk Module Private context. @param FwHiiHandle The Framemwork HII Handle. @return NULL If Framework HII Handle is invalid. @return The corresponding UEFI HII Handle. **/ EFI_HII_HANDLE FwHiiHandleToUefiHiiHandle ( IN CONST HII_THUNK_PRIVATE_DATA *Private, IN FRAMEWORK_EFI_HII_HANDLE FwHiiHandle ) { HII_THUNK_CONTEXT *ThunkContext; ASSERT (FwHiiHandle != (FRAMEWORK_EFI_HII_HANDLE) 0); ASSERT (Private != NULL); ThunkContext = FwHiiHandleToThunkContext (Private, FwHiiHandle); if (ThunkContext != NULL) { return ThunkContext->UefiHiiHandle; } return (EFI_HII_HANDLE) NULL; }
/** 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; }
/** 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; }
/** 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; }