/** This notification function will be called when a Package List is removed using UEFI HII interface. The Package List removed need to be removed from Framework Thunk module too. If the Package List registered is not Sting Package, then ASSERT. If the NotifyType is not REMOVE_PACK, then ASSERT. Both cases means UEFI HII Database itself is buggy. @param PackageType The Package Type. @param PackageGuid The Package GUID. @param Package The Package Header. @param Handle The HII Handle of this Package List. @param NotifyType The reason of the notification. @retval EFI_SUCCESS The notification function is successful. **/ EFI_STATUS EFIAPI RemovePackNotify ( IN UINT8 PackageType, IN CONST EFI_GUID *PackageGuid, IN CONST EFI_HII_PACKAGE_HEADER *Package, IN EFI_HII_HANDLE Handle, IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType ) { EFI_STATUS Status; HII_THUNK_PRIVATE_DATA *Private; HII_THUNK_CONTEXT *ThunkContext; EFI_HII_PACKAGE_LIST_HEADER *HiiPackageList; UINTN BufferSize; Status = EFI_SUCCESS; ASSERT (PackageType == EFI_HII_PACKAGE_STRINGS); ASSERT (NotifyType == EFI_HII_DATABASE_NOTIFY_REMOVE_PACK); if (mInFrameworkHiiRemovePack || mInFrameworkUpdatePakcage) { return EFI_SUCCESS; } Private = mHiiThunkPrivateData; ThunkContext = UefiHiiHandleToThunkContext (Private, Handle); // // BugBug: Change to ASSERT if HII Database fix the bug and to also invoke // NEW_PACK_NOTIFY for package (String Package) created internally. // if (ThunkContext != NULL) { if (!ThunkContext->ByFrameworkHiiNewPack) { HiiPackageList = NULL; Status = ExportPackageLists (Handle, &HiiPackageList, &BufferSize); ASSERT_EFI_ERROR (Status); if (HiiPackageList == NULL) { return EFI_NOT_FOUND; } if (GetPackageCountByType (HiiPackageList, EFI_HII_PACKAGE_STRINGS) == 1) { // // If the string package will be removed is the last string package // in the package list, we will remove the HII Thunk entry from the // database. // DestroyThunkContextForUefiHiiHandle (Private, Handle); } FreePool (HiiPackageList); } } return Status; }
/** Clean up the HII Thunk Context for a UEFI HII Handle. @param Private The HII Thunk Module Private context. @param UefiHiiHandle The UEFI HII Handle. **/ VOID DestroyThunkContextForUefiHiiHandle ( IN HII_THUNK_PRIVATE_DATA *Private, IN EFI_HII_HANDLE UefiHiiHandle ) { HII_THUNK_CONTEXT *ThunkContext; ThunkContext = UefiHiiHandleToThunkContext (Private, UefiHiiHandle); ASSERT (ThunkContext != NULL); DestroyThunkContext (ThunkContext); }
/** This notification function will be called when a Package List is registered using UEFI HII interface. The Package List registered need to be recorded in Framework Thunk module as Thunk Module may need to look for String Package in the package registered. If the Package List registered is not either Sting Package or IFR package, then ASSERT. If the NotifyType is not ADD_PACK or NEW_PACK, then ASSERT. Both cases means UEFI HII Database itself is buggy. @param PackageType The Package Type. @param PackageGuid The Package GUID. @param Package The Package Header. @param Handle The HII Handle of this Package List. @param NotifyType The reason of the notification. @retval EFI_SUCCESS The notification function is successful. **/ EFI_STATUS EFIAPI NewOrAddPackNotify ( IN UINT8 PackageType, IN CONST EFI_GUID *PackageGuid, IN CONST EFI_HII_PACKAGE_HEADER *Package, IN EFI_HII_HANDLE Handle, IN EFI_HII_DATABASE_NOTIFY_TYPE NotifyType ) { EFI_STATUS Status; HII_THUNK_PRIVATE_DATA *Private; HII_THUNK_CONTEXT *ThunkContext; ASSERT (PackageType == EFI_HII_PACKAGE_STRINGS || PackageType == EFI_HII_PACKAGE_FORMS); ASSERT (NotifyType == EFI_HII_DATABASE_NOTIFY_ADD_PACK || NotifyType == EFI_HII_DATABASE_NOTIFY_NEW_PACK); Status = EFI_SUCCESS; Private = mHiiThunkPrivateData; if (mInFrameworkHiiNewPack || mInFrameworkUpdatePakcage) { return EFI_SUCCESS; } // // We will create a ThunkContext to log the package list only if the // package is not registered with by Framework HII Thunk module yet. // ThunkContext = UefiHiiHandleToThunkContext (Private, Handle); if (ThunkContext == NULL) { ThunkContext = CreateThunkContextForUefiHiiHandle (Handle); ASSERT (ThunkContext != NULL); InsertTailList (&Private->ThunkContextListHead, &ThunkContext->Link); } if (PackageType == EFI_HII_PACKAGE_FORMS) { if (ThunkContext->FormSet != NULL) { DestroyFormSet (ThunkContext->FormSet); } // // Reparse the FormSet. // ThunkContext->FormSet = ParseFormSet (ThunkContext->UefiHiiHandle); } return Status; }
/** Parse opcodes in the formset IFR binary. @param FormSet Pointer of the FormSet data structure. @retval EFI_SUCCESS Opcode parse success. @retval Other Opcode parse fail. **/ EFI_STATUS ParseOpCodes ( IN FORM_BROWSER_FORMSET *FormSet ) { EFI_STATUS Status; UINT16 Index; FORM_BROWSER_FORM *CurrentForm; FORM_BROWSER_STATEMENT *CurrentStatement; UINT8 Operand; UINT8 Scope; UINTN OpCodeOffset; UINTN OpCodeLength; UINT8 *OpCodeData; UINT8 ScopeOpCode; FORMSET_STORAGE *Storage; FORMSET_DEFAULTSTORE *DefaultStore; QUESTION_DEFAULT *CurrentDefault; QUESTION_OPTION *CurrentOption; CHAR8 *AsciiString; UINT16 NumberOfStatement; UINT16 NumberOfExpression; EFI_IMAGE_ID *ImageId; EFI_HII_VALUE *Value; LIST_ENTRY *OneOfOptinMapEntryListHead; EFI_IFR_GUID_OPTIONKEY *OptionMap; ONE_OF_OPTION_MAP *OneOfOptionMap; ONE_OF_OPTION_MAP_ENTRY *OneOfOptionMapEntry; UINT8 OneOfType; EFI_IFR_ONE_OF *OneOfOpcode; HII_THUNK_CONTEXT *ThunkContext; EFI_IFR_FORM_MAP_METHOD *MapMethod; mInScopeSubtitle = FALSE; mInScopeSuppress = FALSE; mInScopeGrayOut = FALSE; CurrentDefault = NULL; CurrentOption = NULL; MapMethod = NULL; ThunkContext = UefiHiiHandleToThunkContext ((CONST HII_THUNK_PRIVATE_DATA*) mHiiThunkPrivateData, FormSet->HiiHandle); // // Set to a invalid value. // OneOfType = (UINT8) -1; // // Get the number of Statements and Expressions // CountOpCodes (FormSet, &NumberOfStatement, &NumberOfExpression); FormSet->NumberOfStatement = NumberOfStatement; mStatementIndex = 0; FormSet->StatementBuffer = AllocateZeroPool (NumberOfStatement * sizeof (FORM_BROWSER_STATEMENT)); if (FormSet->StatementBuffer == NULL) { return EFI_OUT_OF_RESOURCES; } InitializeListHead (&FormSet->StorageListHead); InitializeListHead (&FormSet->DefaultStoreListHead); InitializeListHead (&FormSet->FormListHead); InitializeListHead (&FormSet->OneOfOptionMapListHead); CurrentForm = NULL; CurrentStatement = NULL; ResetScopeStack (); OpCodeOffset = 0; while (OpCodeOffset < FormSet->IfrBinaryLength) { OpCodeData = FormSet->IfrBinaryData + OpCodeOffset; OpCodeLength = ((EFI_IFR_OP_HEADER *) OpCodeData)->Length; OpCodeOffset += OpCodeLength; Operand = ((EFI_IFR_OP_HEADER *) OpCodeData)->OpCode; Scope = ((EFI_IFR_OP_HEADER *) OpCodeData)->Scope; // // If scope bit set, push onto scope stack // if (Scope != 0) { PushScope (Operand); } if (IsExpressionOpCode (Operand)) { continue; } // // Parse the Opcode // switch (Operand) { case EFI_IFR_FORM_SET_OP: // // check the formset GUID // if (!CompareGuid ((EFI_GUID *)(VOID *)&FormSet->Guid, (EFI_GUID *)(VOID *)&((EFI_IFR_FORM_SET *) OpCodeData)->Guid)) { return EFI_INVALID_PARAMETER; } CopyMem (&FormSet->FormSetTitle, &((EFI_IFR_FORM_SET *) OpCodeData)->FormSetTitle, sizeof (EFI_STRING_ID)); CopyMem (&FormSet->Help, &((EFI_IFR_FORM_SET *) OpCodeData)->Help, sizeof (EFI_STRING_ID)); break; case EFI_IFR_FORM_OP: // // Create a new Form for this FormSet // CurrentForm = AllocateZeroPool (sizeof (FORM_BROWSER_FORM)); ASSERT (CurrentForm != NULL); CurrentForm->Signature = FORM_BROWSER_FORM_SIGNATURE; InitializeListHead (&CurrentForm->StatementListHead); CopyMem (&CurrentForm->FormId, &((EFI_IFR_FORM *) OpCodeData)->FormId, sizeof (UINT16)); CopyMem (&CurrentForm->FormTitle, &((EFI_IFR_FORM *) OpCodeData)->FormTitle, sizeof (EFI_STRING_ID)); // // Insert into Form list of this FormSet // InsertTailList (&FormSet->FormListHead, &CurrentForm->Link); break; case EFI_IFR_FORM_MAP_OP: // // Create a new Form Map for this FormSet // CurrentForm = AllocateZeroPool (sizeof (FORM_BROWSER_FORM)); ASSERT (CurrentForm != NULL); CurrentForm->Signature = FORM_BROWSER_FORM_SIGNATURE; InitializeListHead (&CurrentForm->StatementListHead); CopyMem (&CurrentForm->FormId, &((EFI_IFR_FORM *) OpCodeData)->FormId, sizeof (UINT16)); MapMethod = (EFI_IFR_FORM_MAP_METHOD *) (OpCodeData + sizeof (EFI_IFR_FORM_MAP)); // // FormMap Form must contain at least one Map Method. // if (((EFI_IFR_OP_HEADER *) OpCodeData)->Length < ((UINTN) (UINT8 *) (MapMethod + 1) - (UINTN) OpCodeData)) { return EFI_INVALID_PARAMETER; } // // Try to find the standard form map method. // while (((UINTN) (UINT8 *) MapMethod - (UINTN) OpCodeData) < ((EFI_IFR_OP_HEADER *) OpCodeData)->Length) { if (CompareGuid ((EFI_GUID *) (VOID *) &MapMethod->MethodIdentifier, &gEfiHiiStandardFormGuid)) { CopyMem (&CurrentForm->FormTitle, &MapMethod->MethodTitle, sizeof (EFI_STRING_ID)); break; } MapMethod ++; } // // If the standard form map method is not found, the first map method title will be used. // if (CurrentForm->FormTitle == 0) { MapMethod = (EFI_IFR_FORM_MAP_METHOD *) (OpCodeData + sizeof (EFI_IFR_FORM_MAP)); CopyMem (&CurrentForm->FormTitle, &MapMethod->MethodTitle, sizeof (EFI_STRING_ID)); } // // Insert into Form list of this FormSet // InsertTailList (&FormSet->FormListHead, &CurrentForm->Link); break; // // Storage // case EFI_IFR_VARSTORE_OP: // // Create a buffer Storage for this FormSet // Storage = CreateStorage (FormSet); Storage->Type = EFI_HII_VARSTORE_BUFFER; CopyMem (&Storage->VarStoreId, &((EFI_IFR_VARSTORE *) OpCodeData)->VarStoreId, sizeof (EFI_VARSTORE_ID)); CopyMem (&Storage->Guid, &((EFI_IFR_VARSTORE *) OpCodeData)->Guid, sizeof (EFI_GUID)); CopyMem (&Storage->Size, &((EFI_IFR_VARSTORE *) OpCodeData)->Size, sizeof (UINT16)); AsciiString = (CHAR8 *) ((EFI_IFR_VARSTORE *) OpCodeData)->Name; Storage->Name = AllocateZeroPool (AsciiStrSize (AsciiString) * 2); ASSERT (Storage->Name != NULL); for (Index = 0; AsciiString[Index] != 0; Index++) { Storage->Name[Index] = (CHAR16) AsciiString[Index]; } break; case EFI_IFR_VARSTORE_NAME_VALUE_OP: // // Framework IFR doesn't support Name/Value VarStore opcode // if (ThunkContext != NULL && ThunkContext->ByFrameworkHiiNewPack) { ASSERT (FALSE); } // // Create a name/value Storage for this FormSet // Storage = CreateStorage (FormSet); Storage->Type = EFI_HII_VARSTORE_NAME_VALUE; CopyMem (&Storage->VarStoreId, &((EFI_IFR_VARSTORE_NAME_VALUE *) OpCodeData)->VarStoreId, sizeof (EFI_VARSTORE_ID)); CopyMem (&Storage->Guid, &((EFI_IFR_VARSTORE_NAME_VALUE *) OpCodeData)->Guid, sizeof (EFI_GUID)); break; case EFI_IFR_VARSTORE_EFI_OP: // // Create a EFI variable Storage for this FormSet // Storage = CreateStorage (FormSet); Storage->Type = EFI_HII_VARSTORE_EFI_VARIABLE; CopyMem (&Storage->VarStoreId, &((EFI_IFR_VARSTORE_EFI *) OpCodeData)->VarStoreId, sizeof (EFI_VARSTORE_ID)); CopyMem (&Storage->Guid, &((EFI_IFR_VARSTORE_EFI *) OpCodeData)->Guid, sizeof (EFI_GUID)); CopyMem (&Storage->Attributes, &((EFI_IFR_VARSTORE_EFI *) OpCodeData)->Attributes, sizeof (UINT32)); break; // // DefaultStore // case EFI_IFR_DEFAULTSTORE_OP: DefaultStore = AllocateZeroPool (sizeof (FORMSET_DEFAULTSTORE)); ASSERT (DefaultStore != NULL); DefaultStore->Signature = FORMSET_DEFAULTSTORE_SIGNATURE; CopyMem (&DefaultStore->DefaultId, &((EFI_IFR_DEFAULTSTORE *) OpCodeData)->DefaultId, sizeof (UINT16)); CopyMem (&DefaultStore->DefaultName, &((EFI_IFR_DEFAULTSTORE *) OpCodeData)->DefaultName, sizeof (EFI_STRING_ID)); // // Insert to DefaultStore list of this Formset // InsertTailList (&FormSet->DefaultStoreListHead, &DefaultStore->Link); break; // // Statements // case EFI_IFR_SUBTITLE_OP: CurrentStatement = CreateStatement (OpCodeData, FormSet, CurrentForm); ASSERT (CurrentStatement != NULL); CurrentStatement->Flags = ((EFI_IFR_SUBTITLE *) OpCodeData)->Flags; if (Scope != 0) { mInScopeSubtitle = TRUE; } break; case EFI_IFR_TEXT_OP: CurrentStatement = CreateStatement (OpCodeData, FormSet, CurrentForm); ASSERT (CurrentStatement != NULL); CopyMem (&CurrentStatement->TextTwo, &((EFI_IFR_TEXT *) OpCodeData)->TextTwo, sizeof (EFI_STRING_ID)); break; // // Questions // case EFI_IFR_ACTION_OP: CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm); ASSERT (CurrentStatement != NULL); if (OpCodeLength == sizeof (EFI_IFR_ACTION_1)) { // // No QuestionConfig present, so no configuration string will be processed // CurrentStatement->QuestionConfig = 0; } else { CopyMem (&CurrentStatement->QuestionConfig, &((EFI_IFR_ACTION *) OpCodeData)->QuestionConfig, sizeof (EFI_STRING_ID)); } break; case EFI_IFR_RESET_BUTTON_OP: CurrentStatement = CreateStatement (OpCodeData, FormSet, CurrentForm); ASSERT (CurrentStatement != NULL); CopyMem (&CurrentStatement->DefaultId, &((EFI_IFR_RESET_BUTTON *) OpCodeData)->DefaultId, sizeof (EFI_DEFAULT_ID)); break; case EFI_IFR_REF_OP: CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm); ASSERT (CurrentStatement != NULL); CopyMem (&CurrentStatement->RefFormId, &((EFI_IFR_REF *) OpCodeData)->FormId, sizeof (EFI_FORM_ID)); if (OpCodeLength >= sizeof (EFI_IFR_REF2)) { CopyMem (&CurrentStatement->RefQuestionId, &((EFI_IFR_REF2 *) OpCodeData)->QuestionId, sizeof (EFI_QUESTION_ID)); if (OpCodeLength >= sizeof (EFI_IFR_REF3)) { CopyMem (&CurrentStatement->RefFormSetId, &((EFI_IFR_REF3 *) OpCodeData)->FormSetId, sizeof (EFI_GUID)); if (OpCodeLength >= sizeof (EFI_IFR_REF4)) { CopyMem (&CurrentStatement->RefDevicePath, &((EFI_IFR_REF4 *) OpCodeData)->DevicePath, sizeof (EFI_STRING_ID)); } } } break; case EFI_IFR_ONE_OF_OP: case EFI_IFR_NUMERIC_OP: CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm); ASSERT (CurrentStatement != NULL); CurrentStatement->Flags = ((EFI_IFR_ONE_OF *) OpCodeData)->Flags; Value = &CurrentStatement->HiiValue; switch (CurrentStatement->Flags & EFI_IFR_NUMERIC_SIZE) { case EFI_IFR_NUMERIC_SIZE_1: CurrentStatement->Minimum = ((EFI_IFR_NUMERIC *) OpCodeData)->data.u8.MinValue; CurrentStatement->Maximum = ((EFI_IFR_NUMERIC *) OpCodeData)->data.u8.MaxValue; CurrentStatement->Step = ((EFI_IFR_NUMERIC *) OpCodeData)->data.u8.Step; CurrentStatement->StorageWidth = sizeof (UINT8); Value->Type = EFI_IFR_TYPE_NUM_SIZE_8; break; case EFI_IFR_NUMERIC_SIZE_2: CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u16.MinValue, sizeof (UINT16)); CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u16.MaxValue, sizeof (UINT16)); CopyMem (&CurrentStatement->Step, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u16.Step, sizeof (UINT16)); CurrentStatement->StorageWidth = sizeof (UINT16); Value->Type = EFI_IFR_TYPE_NUM_SIZE_16; break; case EFI_IFR_NUMERIC_SIZE_4: CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u32.MinValue, sizeof (UINT32)); CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u32.MaxValue, sizeof (UINT32)); CopyMem (&CurrentStatement->Step, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u32.Step, sizeof (UINT32)); CurrentStatement->StorageWidth = sizeof (UINT32); Value->Type = EFI_IFR_TYPE_NUM_SIZE_32; break; case EFI_IFR_NUMERIC_SIZE_8: CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u64.MinValue, sizeof (UINT64)); CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u64.MaxValue, sizeof (UINT64)); CopyMem (&CurrentStatement->Step, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u64.Step, sizeof (UINT64)); CurrentStatement->StorageWidth = sizeof (UINT64); Value->Type = EFI_IFR_TYPE_NUM_SIZE_64; break; default: break; } if (Operand == EFI_IFR_ONE_OF_OP) { OneOfOpcode = (EFI_IFR_ONE_OF *) OpCodeData; OneOfType = (UINT8) (OneOfOpcode->Flags & EFI_IFR_NUMERIC_SIZE); } break; case EFI_IFR_ORDERED_LIST_OP: CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm); ASSERT (CurrentStatement != NULL); CurrentStatement->Flags = ((EFI_IFR_ORDERED_LIST *) OpCodeData)->Flags; CurrentStatement->MaxContainers = ((EFI_IFR_ORDERED_LIST *) OpCodeData)->MaxContainers; CurrentStatement->StorageWidth = (UINT16)(CurrentStatement->MaxContainers * sizeof (UINT8)); // // No buffer type is defined in EFI_IFR_TYPE_VALUE, so a Configuration Driver // has to use FormBrowser2.Callback() to retrieve the uncommited data for // an interactive orderedlist (i.e. with EFI_IFR_FLAG_CALLBACK flag set). // CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_OTHER; CurrentStatement->BufferValue = AllocateZeroPool (CurrentStatement->StorageWidth); break; case EFI_IFR_CHECKBOX_OP: CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm); ASSERT (CurrentStatement != NULL); CurrentStatement->Flags = ((EFI_IFR_CHECKBOX *) OpCodeData)->Flags; CurrentStatement->StorageWidth = sizeof (BOOLEAN); CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_BOOLEAN; break; case EFI_IFR_STRING_OP: CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm); ASSERT (CurrentStatement != NULL); // // MinSize is the minimum number of characters that can be accepted for this opcode, // MaxSize is the maximum number of characters that can be accepted for this opcode. // The characters are stored as Unicode, so the storage width should multiply 2. // CurrentStatement->Minimum = ((EFI_IFR_STRING *) OpCodeData)->MinSize; CurrentStatement->Maximum = ((EFI_IFR_STRING *) OpCodeData)->MaxSize; CurrentStatement->StorageWidth = (UINT16)((UINTN) CurrentStatement->Maximum * sizeof (UINT16)); CurrentStatement->Flags = ((EFI_IFR_STRING *) OpCodeData)->Flags; CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_STRING; CurrentStatement->BufferValue = AllocateZeroPool (CurrentStatement->StorageWidth); break; case EFI_IFR_PASSWORD_OP: CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm); ASSERT (CurrentStatement != NULL); // // MinSize is the minimum number of characters that can be accepted for this opcode, // MaxSize is the maximum number of characters that can be accepted for this opcode. // The characters are stored as Unicode, so the storage width should multiply 2. // CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_PASSWORD *) OpCodeData)->MinSize, sizeof (UINT16)); CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_PASSWORD *) OpCodeData)->MaxSize, sizeof (UINT16)); CurrentStatement->StorageWidth = (UINT16)((UINTN) CurrentStatement->Maximum * sizeof (UINT16)); CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_STRING; CurrentStatement->BufferValue = AllocateZeroPool (CurrentStatement->StorageWidth); break; case EFI_IFR_DATE_OP: CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm); ASSERT (CurrentStatement != NULL); CurrentStatement->Flags = ((EFI_IFR_DATE *) OpCodeData)->Flags; CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_DATE; break; case EFI_IFR_TIME_OP: CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm); ASSERT (CurrentStatement != NULL); CurrentStatement->Flags = ((EFI_IFR_TIME *) OpCodeData)->Flags; CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_TIME; break; // // Default // case EFI_IFR_DEFAULT_OP: // // EFI_IFR_DEFAULT appear in scope of a Question, // It creates a default value for the current question. // A Question may have more than one Default value which have different default types. // CurrentDefault = AllocateZeroPool (sizeof (QUESTION_DEFAULT)); ASSERT (CurrentDefault != NULL); CurrentDefault->Signature = QUESTION_DEFAULT_SIGNATURE; CurrentDefault->Value.Type = ((EFI_IFR_DEFAULT *) OpCodeData)->Type; CopyMem (&CurrentDefault->DefaultId, &((EFI_IFR_DEFAULT *) OpCodeData)->DefaultId, sizeof (UINT16)); CopyMem (&CurrentDefault->Value.Value, &((EFI_IFR_DEFAULT *) OpCodeData)->Value, sizeof (EFI_IFR_TYPE_VALUE)); ExtendValueToU64 (&CurrentDefault->Value); // // Insert to Default Value list of current Question // InsertTailList (&CurrentStatement->DefaultListHead, &CurrentDefault->Link); break; // // Option // case EFI_IFR_ONE_OF_OPTION_OP: // // EFI_IFR_ONE_OF_OPTION appear in scope of a Question. // It create a selection for use in current Question. // CurrentOption = AllocateZeroPool (sizeof (QUESTION_OPTION)); ASSERT (CurrentOption != NULL); CurrentOption->Signature = QUESTION_OPTION_SIGNATURE; CurrentOption->Flags = ((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Flags; CurrentOption->Value.Type = ((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Type; CopyMem (&CurrentOption->Text, &((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Option, sizeof (EFI_STRING_ID)); CopyMem (&CurrentOption->Value.Value, &((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Value, sizeof (EFI_IFR_TYPE_VALUE)); ExtendValueToU64 (&CurrentOption->Value); // // Insert to Option list of current Question // InsertTailList (&CurrentStatement->OptionListHead, &CurrentOption->Link); break; // // Conditional // case EFI_IFR_NO_SUBMIT_IF_OP: case EFI_IFR_INCONSISTENT_IF_OP: break; case EFI_IFR_SUPPRESS_IF_OP: break; case EFI_IFR_GRAY_OUT_IF_OP: break; case EFI_IFR_DISABLE_IF_OP: // // Framework IFR doesn't support DisableIf opcode // if (ThunkContext != NULL && ThunkContext->ByFrameworkHiiNewPack) { ASSERT (FALSE); } // // Expression // case EFI_IFR_VALUE_OP: case EFI_IFR_READ_OP: case EFI_IFR_WRITE_OP: break; case EFI_IFR_RULE_OP: break; // // Image // case EFI_IFR_IMAGE_OP: // // Get ScopeOpcode from top of stack // PopScope (&ScopeOpCode); PushScope (ScopeOpCode); switch (ScopeOpCode) { case EFI_IFR_FORM_SET_OP: ImageId = &FormSet->ImageId; break; case EFI_IFR_FORM_OP: case EFI_IFR_FORM_MAP_OP: ImageId = &CurrentForm->ImageId; break; case EFI_IFR_ONE_OF_OPTION_OP: ImageId = &CurrentOption->ImageId; break; default: // // Make sure CurrentStatement is not NULL. // If it is NULL, 1) ParseOpCodes functions may parse the IFR wrongly. Or 2) the IFR // file is wrongly generated by tools such as VFR Compiler. // ASSERT (CurrentStatement != NULL); ImageId = &CurrentStatement->ImageId; break; } ASSERT (ImageId != NULL); CopyMem (ImageId, &((EFI_IFR_IMAGE *) OpCodeData)->Id, sizeof (EFI_IMAGE_ID)); break; // // Refresh // case EFI_IFR_REFRESH_OP: ASSERT (CurrentStatement != NULL); CurrentStatement->RefreshInterval = ((EFI_IFR_REFRESH *) OpCodeData)->RefreshInterval; break; // // Vendor specific // case EFI_IFR_GUID_OP: OptionMap = (EFI_IFR_GUID_OPTIONKEY *) OpCodeData; if (CompareGuid (&mTianoHiiIfrGuid, (EFI_GUID *)(OpCodeData + sizeof (EFI_IFR_OP_HEADER)))) { // // Tiano specific GUIDed opcodes // switch (((EFI_IFR_GUID_LABEL *) OpCodeData)->ExtendOpCode) { case EFI_IFR_EXTEND_OP_LABEL: // // just ignore label // break; case EFI_IFR_EXTEND_OP_CLASS: CopyMem (&FormSet->Class, &((EFI_IFR_GUID_CLASS *) OpCodeData)->Class, sizeof (UINT16)); break; case EFI_IFR_EXTEND_OP_SUBCLASS: CopyMem (&FormSet->SubClass, &((EFI_IFR_GUID_SUBCLASS *) OpCodeData)->SubClass, sizeof (UINT16)); break; default: break; } } else if (CompareGuid ((EFI_GUID *)(VOID *)&OptionMap->Guid, &mFrameworkHiiCompatibilityGuid)) { if (OptionMap->ExtendOpCode == EFI_IFR_EXTEND_OP_OPTIONKEY) { OneOfOptinMapEntryListHead = GetOneOfOptionMapEntryListHead (FormSet, OptionMap->QuestionId); if (OneOfOptinMapEntryListHead == NULL) { OneOfOptionMap = AllocateZeroPool (sizeof (ONE_OF_OPTION_MAP)); ASSERT (OneOfOptionMap != NULL); OneOfOptionMap->Signature = ONE_OF_OPTION_MAP_SIGNATURE; OneOfOptionMap->QuestionId = OptionMap->QuestionId; // // Make sure OneOfType is initialized. // ASSERT (OneOfType != (UINT8) -1); OneOfOptionMap->ValueType = OneOfType; InitializeListHead (&OneOfOptionMap->OneOfOptionMapEntryListHead); OneOfOptinMapEntryListHead = &OneOfOptionMap->OneOfOptionMapEntryListHead; InsertTailList (&FormSet->OneOfOptionMapListHead, &OneOfOptionMap->Link); } OneOfOptionMapEntry = AllocateZeroPool (sizeof (ONE_OF_OPTION_MAP_ENTRY)); ASSERT (OneOfOptionMapEntry != NULL); OneOfOptionMapEntry->Signature = ONE_OF_OPTION_MAP_ENTRY_SIGNATURE; OneOfOptionMapEntry->FwKey = OptionMap->KeyValue; CopyMem (&OneOfOptionMapEntry->Value, &OptionMap->OptionValue, sizeof (EFI_IFR_TYPE_VALUE)); InsertTailList (OneOfOptinMapEntryListHead, &OneOfOptionMapEntry->Link); } } break; // // Scope End // case EFI_IFR_END_OP: Status = PopScope (&ScopeOpCode); if (EFI_ERROR (Status)) { ResetScopeStack (); return Status; } switch (ScopeOpCode) { case EFI_IFR_FORM_SET_OP: // // End of FormSet, update FormSet IFR binary length // to stop parsing substantial OpCodes // FormSet->IfrBinaryLength = OpCodeOffset; break; case EFI_IFR_FORM_OP: case EFI_IFR_FORM_MAP_OP: // // End of Form // CurrentForm = NULL; break; case EFI_IFR_ONE_OF_OPTION_OP: // // End of Option // CurrentOption = NULL; break; case EFI_IFR_SUBTITLE_OP: mInScopeSubtitle = FALSE; break; case EFI_IFR_NO_SUBMIT_IF_OP: case EFI_IFR_INCONSISTENT_IF_OP: // // Ignore end of EFI_IFR_NO_SUBMIT_IF and EFI_IFR_INCONSISTENT_IF // break; case EFI_IFR_GRAY_OUT_IF_OP: mInScopeGrayOut = FALSE; break; default: if (IsExpressionOpCode (ScopeOpCode)) { } break; } break; default: break; } } return EFI_SUCCESS; }
/** 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; }