diff options
Diffstat (limited to 'Core/CORE_DXE/FrameworkHii/HIIDB.c')
| -rw-r--r-- | Core/CORE_DXE/FrameworkHii/HIIDB.c | 3511 |
1 files changed, 3511 insertions, 0 deletions
diff --git a/Core/CORE_DXE/FrameworkHii/HIIDB.c b/Core/CORE_DXE/FrameworkHii/HIIDB.c new file mode 100644 index 0000000..b4bfbfc --- /dev/null +++ b/Core/CORE_DXE/FrameworkHii/HIIDB.c @@ -0,0 +1,3511 @@ +//********************************************************************** +//********************************************************************** +//** ** +//** (C)Copyright 1985-2005, American Megatrends, Inc. ** +//** ** +//** All Rights Reserved. ** +//** ** +//** 6145-F Northbelt Pkwy, Norcross, GA 30071 ** +//** ** +//** Phone: (770)-246-8600 ** +//** ** +//********************************************************************** +//********************************************************************** + +//********************************************************************** +// $Header: /Alaska/SOURCE/Core/CORE_DXE/FrameworkHii/HIIDB.c 5 2/10/10 5:08p Felixp $ +// +// $Revision: 5 $ +// +// $Date: 2/10/10 5:08p $ +//********************************************************************** +// Revision History +// ---------------- +// $Log: /Alaska/SOURCE/Core/CORE_DXE/FrameworkHii/HIIDB.c $ +// +// 5 2/10/10 5:08p Felixp +// Bug fix in HiiExtGetFormInfo function. +// +// 4 2/10/10 3:43p Felixp +// x64 compiler warnings are fixed. +// +// 3 12/29/09 2:38p Yakovlevs +// Fixed issue with hanging in TSE big number of setup questions. +// Changed size of Length fields in some HII internal structures from +// UIN16 to UINTN. +// Code clenup (removed not used variables changes to compile with W4) +// +// 2 12/04/09 2:16p Yakovlevs +// 1.Fixed potential NULL pointer use in function NewFontPack() +// 2.Fixed inconsistancy in VarStore management (requires updated HiiDb.h) +// +// 1 10/09/09 6:10p Felixp +// +// 45 6/03/09 10:58a Yakovlevs +// if Hii->RemovePack is called reset global pointers to NULL since they +// might pointing at data that was freed. +// +// 44 10/01/08 1:01p Yakovlevs +// fixed bug in HiiExtGetFormLabels() function. +// +// 43 1/09/08 10:49a Yakovlevs +// +// 42 9/05/07 9:18p Felixp +// +// 41 9/05/07 5:59p Yakovlevs +// Bug fixes in UpdateForm and RemovePack routines. +// +// 2 6/28/07 5:16p Yakovlevs +// Fixed FormUpdate Protocol Function, and some other minor bug fixes. +// +// 39 5/23/07 4:32p Pavell +// Reindexing formsets +// +// 38 3/18/07 3:10p Felixp +// GetSecondaryLanguages fix: return EFI_NOT_FOUND when no languages found +// +// 37 3/12/07 6:06p Yakovlevs +// Fixed NewKbPack function. +// +// 36 3/12/07 1:46p Yakovlevs +// Handled a situation when there are no Keyboard Layout data in HII +// Database. +// +// 35 3/07/07 8:21p Yakovlevs +// Added GetKeyboardLayout function implamentation. +// +// 34 1/23/07 12:23p Yakovlevs +// +// 33 12/21/06 1:57p Felixp +// +// 32 12/20/06 10:37a Felixp +// +// 31 12/18/06 5:42p Pavell +// Added a fix for variable size determination +// 30 11/15/06 5:55p Yakovlevs +// +// 29 11/02/06 6:45p Yakovlevs +// Fixed HiiTestString NON_SPACING attribute handling +// +// 27 10/31/06 11:15a Yakovlevs +// HiiTestString fixed to skip none spacing characters. +// +// 25 10/30/06 6:09p Yakovlevs +// HII Spec v 0.92 updates +// +// 24 9/27/06 7:44p Felixp +// Improvement in GetHiiString: +// If string is not found for the current system language language, try +// with the package primary language. +// +// 23 9/26/06 9:03a Felixp +// Multilanguage Support. Do not use hard-coded glyphs. Load font file +// instead. +// +// 22 9/18/06 6:23p Felixp +// Bug fix in HiiGetString: buffer overrun when Raw is FALSE +// +// 21 8/24/06 10:11a Felixp +// x64 support: warning/error fixes +// +// 20 8/04/06 5:18p Felixp +// Bug fix in NewFontPack function (wide glyph handling). +// +// 19 7/24/06 11:46a Yakovlevs +// Hii->ExportDatabase support added. +// +// 18 3/13/06 5:30p Felixp +// +// 17 10/03/05 2:47p Markw +// Fixed uninitialized variables. +// +// 16 7/20/05 6:43p Felixp +// GlyphToBlt modifed to support wide characters +// +// 15 7/19/05 8:17p Felixp +// NewString modified to support update for all languages when three +// spaces Language provided +// +// 13 7/13/05 9:46p Felixp +// +// 12 6/24/05 2:03p Yakovlevs +// +// 11 6/23/05 5:43p Yakovlevs +// Fixed "Missing String" message +// +// 10 5/27/05 12:16p Felixp +// bug fix in HiiGetString +// +// 9 2/28/05 6:21p Yakovlevs +// Fixed DateTime and Object Conditions issue; +// +// 8 3/17/05 1:57p Felixp +// implementation of HiiNewPackNew updated +// +// 7 3/04/05 12:52p Felixp +// +// 6 3/04/05 9:23a Mandal +// + +//********************************************************************** +//<AMI_FHDR_START> +// +// Name: <This File Name> +// +// Description: +// +//<AMI_FHDR_END> +//********************************************************************** +// +// Module Name: HIIDB.C +// +// Abstract: This file contains implementation of HII Database Protocol. +// +#include <HiiDb.h> +#include <Protocol/DevicePath.h> +#include <Protocol/HiiUtilities.h> +extern UINT8 *UsStdNarrowGlyphData; +extern HII_UTILITIES_PROTOCOL HiiUtilitiesProtocol; + +//================================================================================== +// Some globals we need +//================================================================================== + +//------------------------------------------ +//Prototypes +EFI_STATUS InitPrivateData(EFI_HANDLE MyImgHandle); +EFI_STATUS CreateLabelObjects(HII_LABEL *Label); +//EFI_STATUS HiiNewPack (IN EFI_HII_PROTOCOL *This, +// IN EFI_HII_PACK_LIST *Package, +// OUT EFI_HII_HANDLE *Handle); + +//------------------------------------------ +//GUIDs +EFI_GUID gEfiHiiProtocolGuidOld = EFI_HII_OLD_PROTOCOL_GUID; +EFI_GUID gEfiHiiProtocolGuidNew = EFI_HII_NEW_PROTOCOL_GUID; +static EFI_GUID gEfiExtHiiProtocolGuid = EFI_HII_EXT_PROTOCOL_GUID; +//------------------------------------------ +//Data Vars + +//Define String Database Key fields +#define STR_KEY 0 +#define STR_KEY_CNT 1 +//it is going to be combined key +//Token->size16;LangIdx->size32;Handle->size16; total = 8 byte->UINT64 +//Token->Least Segnificant Field Handle Most Significant Field +//the resulting Index for StringToken->23, LangIndex->2, Hii Handle=1 will be +// Handle|LangIdx |Token +// 0x0001|00000002|0023 -> easy to sort easy to find +static DBE_OFFSET_KEY_CONTEXT gStrOffsetInfo = {EFI_FIELD_OFFSET(HII_STR ,Token), 8 }; +static DBE_KEY_FIELD gStrKey=OFFSET_KEY(gStrOffsetInfo); + +//Any Language Printable string +static UINT16 gAnyLang[]=L"Any Language"; +//HII DATABASE global var +static HII_DB gHiiDb; + +/////////////////////////////////////////////////////////////////// +//in order to save some time when LocateHandle routine been called +//I have decide to save Current HandleInfo structure pionter +//here rather than locate it every time +static HII_HANDLE *mCurHnd=NULL; +static HII_LANG *mCurLang=NULL; +static UINTN mCurHid=0, mCurLid=0; + +/////////////////////////////////////////////////////////////////// +//in order to save some time when HiiGetLine routine been called +//I have decide to save Current StringInfo structure pionter +//here rather than locate it every time HiiGetLine been called +static HII_STR *mCurStr=NULL; + +/////////////////////////////////////////////////////////////////// +// save the varstore context based on the formset +static UINT16 CurrentVarId = 0; + +//================================================================================== +// Entry Point +//================================================================================== +//********************************************************************** +//<AMI_PHDR_START> +// +// Procedure: HiiDbEntryPoint() +// +// Description: Initialize HII Database (Standard EFI Image entry - EFI_IMAGE_ENTRY_POINT) +// +// Input: EFI_HANDLE ImageHandle This Driver Image Handle. +// EFI_SYSTEM_TABLE *SystemTable Pointer to the EFI System Table +// +// Output: EFI_STATUS EFI_SUCCESS - Driver Loadded. +// Other - Driver Error +// +//<AMI_PHDR_END> +//********************************************************************** + +EFI_STATUS HiiDbEntryPoint(IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable){ + EFI_STATUS Status=0; + UINTN hCnt; + EFI_HANDLE *hBuf; +//----------------------------------- + InitAmiLib(ImageHandle, SystemTable); + + //Only one HII Driver has to be in the system + Status=pBS->LocateHandleBuffer(ByProtocol, &gEfiHiiProtocolGuidOld, NULL, &hCnt, &hBuf); + + //If there was no error, report that we has been already started + if (!EFI_ERROR(Status)) { + if (!hBuf)pBS->FreePool(hBuf); //Don't forget to free the memory + return EFI_ALREADY_STARTED; + } + + Status=InitPrivateData(ImageHandle); + if(EFI_ERROR(Status)) return Status; + + Status = pBS->InstallMultipleProtocolInterfaces(&gHiiDb.HiiHandle, + &gEfiHiiProtocolGuidOld,&gHiiDb.HiiProtocolOld, + &gEfiHiiProtocolGuidNew,&gHiiDb.HiiProtocolNew, + &gEfiExtHiiProtocolGuid,&gHiiDb.HiiExtProtocol, + &gHiiUtilitiesProtocolGuid, &HiiUtilitiesProtocol, + NULL); + return Status; +} + +/////////////////////////////////////////////////////////////////// +// Common Worker Functions +/////////////////////////////////////////////////////////////////// +//************************************************************************* +//<AMI_PHDR_START> +// +// Name: GetDefaultLang +// +// Description: +// EFI_STATUS GetDefaultLang(OUT CHAR16 *DefaultLang) returns the default +// system language in the string specified by DefaultLang. +// +// Input: +// OUT CHAR16 *DefaultLang +// Pointer to the null-terminated Unicode string. +// +// Output: +// EFI_NOT_FOUND, if the default language could not be found. +// Otherwise, EFI_SUCCESS. +// +// Modified: +// +// Referrals: +// +// Notes: +// +//<AMI_PHDR_END> +//************************************************************************* +//Get System Default Language +EFI_STATUS GetDefaultLang(CHAR16 *DefaultLang){ + EFI_GUID EfiGlobalVariableGuid = EFI_GLOBAL_VARIABLE; + EFI_STATUS Status=0; + UINT8 al[3]; + UINTN i=sizeof(al); +//----------------------- + Status=pRS->GetVariable(L"Lang",&EfiGlobalVariableGuid,NULL,&i,al); + if (EFI_ERROR(Status)) return Status; + + for(i=0; i<sizeof(al) ;i++) DefaultLang[i]=al[i]; + DefaultLang[sizeof(al)]=0; + return Status; +} + +//----------------------------------------------------------------- +//This Function will look in Item List and try to find mutch for Item of Size. +//if it finds it will return Pointer to the matching Item and update Index if not - NULL +EFI_STATUS LocateItem(T_ITEM_LIST *ItemLst, VOID *Item, UINTN Size, OUT UINTN *Index){ + UINTN i; +//----------------- + for(i=0; i<ItemLst->ItemCount; i++){ + if(!MemCmp(ItemLst->Items[i],Item,Size)) { + if(Index)*Index=i; + return EFI_SUCCESS; + } + } + return EFI_NOT_FOUND; +} + +/////////////////////////////////////////////////////////////////// +//Will return Lenth of the screen representation of Str with respect +//of wide narrow and non spacing glyphs it using +//Len excluding '0' char (\n) +UINT16 GetScrLen(CHAR16 *Str, UINT16 Len){ + UINTN i; + UINT16 u,sl=0; + HII_N_FONT *fnt; +//-------------------------------------- + for(i=0;i<Len;i++){ + u=Str[i]; + if(u<0x20 || u>=0xfff0)continue; + fnt=gHiiDb.FontDb[u]; + if(fnt){ + if(fnt->Attr & GLYPH_NON_SPACING) continue; + if(fnt->Attr & GLYPH_WIDE) sl+=2; + else sl++; + } else sl++; //we will print empty rect for non existent glyph + } + return sl; +} + +/////////////////////////////////////////////////////////////////// +//Will allocate Mem for the length of the string and Copy "Str" there +UINT16* StrAlloc(UINT16 *Str,UINT16 *StrLen OPTIONAL, UINT16 *ScrLen OPTIONAL){ + UINT16 len; + UINT16 *str; +//------------------------------------- + len=(UINT16)Wcslen(Str);//terminator not included + str=(UINT16*)Malloc((len+1)*sizeof(UINT16)); + if(!str)return NULL; + Wcscpy(str,Str); + if(StrLen)*StrLen=len+1; + if(ScrLen)*ScrLen=GetScrLen(Str,len); + return str; +} + +/////////////////////////////////////////////////////////////////// +//This will Change Language Attributes +//VOID SetLangAttr(UINTN Index, UINT32 Attr){ +// HII_LANG *lang; +//-------------------- +// lang=(HII_LANG*)gHiiDb.LangDb.ResDsc[Index]; +// lang->Attr=Attr; +//} + +/////////////////////////////////////////////////////////////////// +//this will find and return HII_LANG "Index", +//if "Language" is stored In Hii Handle Database +HII_LANG* LocateLang(UINT16 *Language, UINTN *Index){ + EFI_STATUS Status; + UINTN idx; +//------------------------ + if( !mCurLang || MemCmp(&mCurLang->sName[0],Language,sizeof(mCurLang->sName)) ) + { + Status=LocateItem(&gHiiDb.LangDb,Language,sizeof(UINT16)*4,&idx); + if(EFI_ERROR(Status)){ + mCurLang=NULL; //flush Language Cache + mCurLid=0; //make index to generate exception if used + } else { + mCurLang=gHiiDb.LangDb.Items[idx]; + mCurLid=idx; + } + } + if(mCurLang && Index)*Index=mCurLid; + return mCurLang; +} + +HII_HANDLE *LocateHandleGuid(EFI_GUID *Guid, UINTN *Index){ + HII_HANDLE *phnd=NULL; + UINTN i; +//------------------------------- + for(i=0; i<gHiiDb.HandleDb.ItemCount; i++){ + phnd=gHiiDb.HandleDb.Items[i]; + if(!MemCmp(&phnd->Guid,Guid,sizeof(EFI_GUID)))break; + else phnd=NULL; + } + if(phnd && Index)*Index=i; + return phnd; +} + +/////////////////////////////////////////////////////////////////// +//This function will Locate another Handle with the same Guid as +//passed Handle. +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO +//This function is Obsolete but I need it for compliance with Intel's +//Setup because they using same guid more than once per Ifr and Strings pare. +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO +VOID LocateSameGuidHandle(UINTN CurIdx, UINTN *IdxBuffer, UINTN *IdxCount){ + HII_HANDLE *phnd=NULL,*chnd=gHiiDb.HandleDb.Items[CurIdx]; + UINTN i, c=0; +//---------------------------- + for(i=0; i<gHiiDb.HandleDb.ItemCount; i++){ + if(i==CurIdx) continue; + phnd=gHiiDb.HandleDb.Items[i]; + if(!MemCmp(&phnd->Guid,&chnd->Guid,sizeof(EFI_GUID))){ + IdxBuffer[c]=i; + c++; + }else phnd=NULL; + } + *IdxCount=c; +} + +/////////////////////////////////////////////////////////////////// +//if on passed handle in any string function there are no +//strings associated with we need to find another handle with +//the same guid having strings on it +HII_HANDLE *LocateStrHandleGuid(UINTN CurIdx, UINTN *Index){ + HII_HANDLE *phnd=NULL,*chnd=gHiiDb.HandleDb.Items[CurIdx]; + UINTN i; +//---------------------------- + for(i=0; i<gHiiDb.HandleDb.ItemCount; i++){ + if(i==CurIdx) continue; + phnd=gHiiDb.HandleDb.Items[i]; + if(!MemCmp(&phnd->Guid,&chnd->Guid,sizeof(EFI_GUID)) && phnd->HasStr){ + if(Index)*Index=i; + break; + }else phnd=NULL; + } + return phnd; +} + +/////////////////////////////////////////////////////////////////// +//this will find and return HII_HANDLE "Index", +//if "Handle" is stored In Hii Handle Database +static HII_HANDLE* LocateHandle(EFI_HII_HANDLE Handle, UINTN *Index){ + EFI_STATUS Status; + UINTN idx; +//------------------------ + if((!mCurHnd) || (mCurHnd->Handle!=Handle)){ + Status=LocateItem(&gHiiDb.HandleDb,&Handle,sizeof(EFI_HII_HANDLE),&idx); + if(EFI_ERROR(Status)){ + mCurHnd=NULL; //flush Handle Cache + mCurHid=-1; //make index to generate exception if used + } else { + mCurHnd=gHiiDb.HandleDb.Items[idx]; + mCurHid=idx; + } + } + if(mCurHnd && Index)*Index=mCurHid; + return mCurHnd; +} + +/////////////////////////////////////////////////////////////////// +//this will find and return HII_HANDLE "Index", +//if "Handle" is stored in Handle Database +//or Append Handle Database with this Handle if not and return a new "Index" +EFI_STATUS LocateHandleAdd(EFI_HII_HANDLE Handle, EFI_GUID *GuidId, UINTN *Index){ + EFI_STATUS Status=0; + HII_HANDLE *phnd; +//---------------- + phnd=LocateHandle(Handle,Index); + if(!phnd){ + phnd=MallocZ(sizeof(HII_HANDLE)); + if(!phnd)return EFI_OUT_OF_RESOURCES; + pBS->CopyMem(&phnd->Guid,GuidId,sizeof(EFI_GUID)); + phnd->Handle=Handle; + Status=AppendItemLst(&gHiiDb.HandleDb,phnd); + if(EFI_ERROR(Status)) return Status; + *Index=gHiiDb.HandleDb.ItemCount-1; + } + return EFI_SUCCESS; +} + +/////////////////////////////////////////////////////////////////// +//this will find and return HII_LANG "Index", +//if "Language" is stored in Handle Database +//or Append Handle Database with this Handle if not and return a new "Index" +EFI_STATUS LocateLangAdd(UINT16 *Language, UINT16 *PrintLanguage, UINTN *Index){ + EFI_STATUS Status; + HII_LANG *lang; +//------------------ + //Check if we have the Language installed already + lang=LocateLang(Language,Index); + if(!lang){ + lang=MallocZ(sizeof(HII_LANG)); + if(!lang)return EFI_OUT_OF_RESOURCES; + pBS->CopyMem(&lang->sName,Language,sizeof(UINT16)*4); + if(PrintLanguage){ + lang->lName=StrAlloc(PrintLanguage,NULL,NULL); + if(!lang->lName) return EFI_OUT_OF_RESOURCES; + } + Status=AppendItemLst(&gHiiDb.LangDb,lang); + if(EFI_ERROR(Status)) return Status; + if(Index)*Index=gHiiDb.LangDb.ItemCount-1; + } + return EFI_SUCCESS; +} + + +/////////////////////////////////////////////////////////////////// +//This will check if Lang Index is present in Secondary Lang List +//on this Handle +/////////////////////////////////////////////////////////////////// +EFI_STATUS LocateSecLangAdd(HII_HANDLE *Hnd, UINTN *SecLangIdx, BOOLEAN AddIt){ + UINTN i; +//------------------------------ + for(i=0; i<Hnd->SecLang.ItemCount; i++){ + if(*SecLangIdx==(UINTN)(Hnd->SecLang.Items[i])) return EFI_SUCCESS; + } + if(AddIt)return AppendItemLst(&Hnd->SecLang,(VOID*)(*SecLangIdx)); + else return EFI_NOT_FOUND; +} + + +/////////////////////////////////////////////////////////////////// +//================================================================= +//HII Database Protocol Functions +//================================================================= +/////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////// +// Font related +/////////////////////////////////////////////////////////////////// +EFI_STATUS NewFontPack(IN EFI_HII_FONT_PACK *Package) +{ + UINTN i; + UINT16 u; + EFI_NARROW_GLYPH *ng; + EFI_WIDE_GLYPH *wg; +//-------------------------- + + //Set Pointer to the beginning of Package Data. + ng=(EFI_NARROW_GLYPH*)(Package+1); + + if(Package->NumberOfNarrowGlyphs){ + HII_N_FONT *fnt; + //--------------------------- + //Allocate Space for Number of Narrow Glyphs + fnt=(HII_N_FONT*)Malloc(sizeof(HII_N_FONT)*Package->NumberOfNarrowGlyphs); + if(!fnt)return EFI_OUT_OF_RESOURCES; + + for(i=0; i<Package->NumberOfNarrowGlyphs; i++){ + u=ng[i].UnicodeWeight; +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO + //we will populate only empty spots in FontD or oposite +//made SDL token for that + if(!gHiiDb.FontDb[u]){ +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO + //fnt=(HII_FONT*)Malloc(sizeof(HII_FONT)); + pBS->CopyMem((VOID*)&fnt[i], &ng[i].Attributes,sizeof(HII_N_FONT)); + gHiiDb.FontDb[u]=&fnt[i]; + } + } + } + + + if(Package->NumberOfWideGlyphs){ + UINTN j,k; + HII_W_FONT *fnt; + //--------------- + //Allocate Space for Number of Wide Glyphs + wg=(EFI_WIDE_GLYPH*)(ng+Package->NumberOfNarrowGlyphs); + fnt=(HII_W_FONT*)Malloc((sizeof(HII_W_FONT))*Package->NumberOfWideGlyphs); + if(!fnt)return EFI_OUT_OF_RESOURCES; + + for(i=0; i<Package->NumberOfWideGlyphs; i++){ + u=wg[i].UnicodeWeight; + if(!gHiiDb.FontDb[u]){ + fnt[i].Attr=wg[i].Attributes; + for(j=0,k=0; j<NG_SIZE;j++, k+=2){ + fnt[i].GlData[k]=wg[i].GlyphCol1[j]; + fnt[i].GlData[k+1]=wg[i].GlyphCol2[j]; + } + gHiiDb.FontDb[u]=(HII_N_FONT*)&fnt[i]; + } + } + } + return EFI_SUCCESS; +} + + + +/////////////////////////////////////////////////////////////////// +EFI_STATUS HiiTestString(IN EFI_HII_PROTOCOL *This, + IN CHAR16 *StringToTest, + IN OUT UINT32 *FirstMissing, + OUT UINT32 *GlyphBufferSize) +{ + EFI_STATUS Status=0; + UINT32 i; + UINT32 bs=0; + HII_N_FONT *fnt; +//------------------------------ + if(!This) return EFI_INVALID_PARAMETER; + if ((!FirstMissing)||(!StringToTest)||(!GlyphBufferSize)) return EFI_INVALID_PARAMETER; + + i=*FirstMissing; + while (StringToTest[i]!=0){ + fnt=gHiiDb.FontDb[ StringToTest[i] ]; + if(fnt){ + if(fnt->Attr& GLYPH_NON_SPACING ){ + i++; + continue; + } + if(fnt->Attr&GLYPH_WIDE) bs+=WG_SIZE; + else bs+=NG_SIZE; + i++; + } else { + Status=EFI_NOT_FOUND; + break; + } + } + *FirstMissing=i; + *GlyphBufferSize=bs; + return Status; +} + +static UINT8 gGE[NG_SIZE]= + {0x00,0x00,0x00,0x7E,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x7E,0x00,0x00,0x00};// \ +// 0x00,0x00,0x00,0x7E,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x7E,0x00,0x00,0x00}; + +static EFI_WIDE_GLYPH gGB; +/////////////////////////////////////////////////////////////////// +EFI_STATUS HiiGetGlyph(IN EFI_HII_PROTOCOL *This, + IN CHAR16 *Source, + IN OUT UINT16 *Index, + OUT UINT8 **GlyphBuffer, + OUT UINT16 *BitWidth, + IN OUT UINT32 *InternalStatus) +{ + UINTN i, bs=NG_SIZE; + HII_N_FONT *fnt;//=gHiiDb.FontDb[Source[j]]; +// HII_GL_COL *gc1=NULL, *gc2=NULL; +// BOOLEAN w=FALSE; +//------------------------------------------ + if(!This) return EFI_INVALID_PARAMETER; + + if((!GlyphBuffer)||(!Index)||(!Source)||(!BitWidth)) return EFI_INVALID_PARAMETER; + fnt=gHiiDb.FontDb[Source[*Index]]; + + if(!fnt) { + if(InternalStatus)*InternalStatus=(UINT32)-1; + //If after calling TestString somebody will call us with invalid Unicode Char + pBS->CopyMem(&gGB.GlyphCol1[0],&gGE, NG_SIZE); + *BitWidth=GLYPH_W; + *GlyphBuffer=(UINT8*)&gGB; + (*Index)++; + return EFI_NOT_FOUND; + } + + //first char must not be the non-spacing character + if(fnt->Attr&GLYPH_NON_SPACING) return EFI_INVALID_PARAMETER; + + if(fnt->Attr&GLYPH_WIDE){ + *BitWidth=GLYPH_W*2; + bs=WG_SIZE; + } else *BitWidth=GLYPH_W; + + pBS->SetMem(&gGB,sizeof(EFI_WIDE_GLYPH),0); + do{ + fnt=gHiiDb.FontDb[Source[*Index]]; + for(i=0;i<bs;i++) gGB.GlyphCol1[i]|=fnt->GlData[i]; + (*Index)++; + } while(fnt->Attr&GLYPH_NON_SPACING); + *GlyphBuffer=(UINT8*)&gGB; + if(InternalStatus)*InternalStatus=0; + + return EFI_SUCCESS; +} + + +/////////////////////////////////////////////////////////////////// +//!!!! this function suppose to take care of thing with mixed size gpyphs +EFI_STATUS HiiGlyphToBlt(IN EFI_HII_PROTOCOL *This, + IN UINT8 *GlyphBuffer, + IN EFI_UGA_PIXEL Foreground, + IN EFI_UGA_PIXEL Background, + IN UINTN Count,//Number of NARROW Glyps left in BltBuffer + //or count from the end of the buffer in terms of NARROW glyphs + IN UINTN Width, + IN UINTN Height, + IN OUT EFI_UGA_PIXEL *BltBuffer) +{ +// UINTN x,y;//,i,o; +// UINT8 k = Width > GLYPH_W ? 2 : 1; +//------------------------------------ +// if(!This) return EFI_INVALID_PARAMETER; +// if( !(Width==GLYPH_W || Width==(GLYPH_W*2)) || Height!=GLYPH_H )return EFI_INVALID_PARAMETER; +/* for (y=0,o=0; y<Height; y++){ + for(i=0; i<Width/GLYPH_W; i++){ + for (x=0; x<GLYPH_W; x++){ + if ( GlyphBuffer[y*k+i] & (0x80 >> x)) BltBuffer[y*GLYPH_W*Count+x+o]=Foreground; + else BltBuffer[y*GLYPH_W*Count+x+o]=Background; + } + o=GLYPH_W; + } + } + + return EFI_SUCCESS; + UINTN X; + UINTN Y; +*/ + UINT8 Mask; + UINTN Index, Line, Part; + UINTN TotalParts = Width/GLYPH_W; + EFI_NARROW_GLYPH *Glyph = (EFI_NARROW_GLYPH *)GlyphBuffer; + if(!This) return EFI_INVALID_PARAMETER; + if( !(Width==GLYPH_W || Width==GLYPH_W*2) || Height!=GLYPH_H || Count<TotalParts)return EFI_INVALID_PARAMETER; + for (Line = 0, Index=0; Line < Height; Line++, Index+=GLYPH_W * (Count-TotalParts)) { + for(Part=0; Part<TotalParts; Part++){ + for (Mask = 0x80; Mask > 0; Mask>>=1, Index++) { + if (Glyph->GlyphCol1[Line*TotalParts+Part] & Mask) + BltBuffer[Index] = Foreground; + else + BltBuffer[Index] = Background; + } + } + } +/*/// + BltBuffer[Index] = (Glyph->GlyphCol1[y] & (1 << x)) ? Foreground : Background; + if (Width > GLYPH_W) + BltBuffer[Index+GLYPH_W] = (Glyph->GlyphCol1[GLYPH_H+y] & (1 << x)) ? Foreground : Background; +/// + EFI_NARROW_GLYPH *Glyph = (EFI_NARROW_GLYPH *)GlyphBuffer; + for (y = 0; y < Height; y++) { + for (x = 0; x < GLYPH_W; x++) { + UINTN Index = y * GLYPH_W * Count + (GLYPH_W - x - 1); + for(i=0; i<Width/GLYPH_W; i++) + if ((Glyph->GlyphCol1[i*GLYPH_H+y] & (1 << x)) != 0) + BltBuffer[Index+GLYPH_W*i] = Foreground; + else + BltBuffer[Index+GLYPH_W*i] = Background; + } + }*/ + return EFI_SUCCESS; +} + +/////////////////////////////////////////////////////////////////// +// String related +/////////////////////////////////////////////////////////////////// +HII_STR *LocateString(HII_HANDLE *PHnd, UINTN LangIdx, STRING_REF Token/*, UINTN HandleIdx OPTIONAL*/){ + UINTN li=LangIdx, j; + HII_STR sd = {0,0,0,0,NULL}; + INT8 v; + VOID **cs; +//----------------- + //if CurrentString must be refreshed + if(!mCurStr || mCurStr->LangIdx!=LangIdx || mCurStr->Token!=Token || mCurStr->Handle!=PHnd->Handle) + { + + //--------------------- + do { + sd.Handle=PHnd->Handle; + sd.LangIdx=(UINT32)li; + sd.Token=Token; + + DbeLocateKey(&gHiiDb.StringDb,STR_KEY,(VOID*)&sd,(VOID**)&cs,&v,&j); + + if(v)mCurStr=NULL; + else { + mCurStr=(HII_STR*)(*cs); + break; + } + + //if we were looking for any language and failed + //just get Primary Package Language + if(!li)li=PHnd->PriLang; + else break; + } while(v); +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO +//this patch was made to keep compatibility with Intel's implemntation +//of BDS - DevicerManagerVfrBin and FrontPageVfrBin uses the same Guid +//and Same String Pack expecting valid strings on from one StringPack +//when passing different GUIDs????????? +/* if(!mCurStr){ + HII_HANDLE *phnd; + UINTN i,sgib[10]={0,0,0,0,0,0,0,0,0,0};//same GUID index Buffer + //---------------------------------- + LocateSameGuidHandle(HandleIdx,&sgib[0],&c); + for(i=0; i<c;i++){ + li=LangIdx; + phnd=gHiiDb.HandleDb.Items[sgib[i]]; + do { + sd.Handle=phnd->Handle; + sd.LangIdx=(UINT32)li; + sd.Token=Token; + + DbeLocateKey(&gHiiDb.StringDb,STR_KEY,(VOID*)&sd,(VOID**)&cs,&v,&j); + + if(v)mCurStr=NULL; + else { + mCurStr=(HII_STR*)(*cs); + break; + } + //if we were looking for any language and faild + //just get Primary Package Language + if(!li)li=PHnd->PriLang; + else break; + } while(v); + if(mCurStr)break; + } + } +*/ +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO + } + return mCurStr; +} + +/////////////////////////////////////////////////////////////////// +EFI_STATUS ReplaceString(HII_STR *StrData, UINT16 *Replacement) +{ + UINT16 *str; + UINT16 len,slen; +//----------------------------- + str=StrAlloc(Replacement, &len, &slen); + if(!str)return EFI_OUT_OF_RESOURCES; + + if(StrData->NewStr.StrPtr)pBS->FreePool(StrData->NewStr.StrPtr); + + StrData->NewStr.StrLen=len; + StrData->NewStr.ScrLen=slen; + StrData->NewStr.StrPtr=str; + + return EFI_SUCCESS; +} + +/////////////////////////////////////////////////////////////////// +EFI_STATUS AddString(UINTN LangIdx, HII_HANDLE *PHandle, UINT16 *String, BOOLEAN Initial, STRING_REF *Token) +{ + HII_STR *str; +//------------------------------------- + str=MallocZ(sizeof(HII_STR)); + if(!str) return EFI_OUT_OF_RESOURCES; + + if(Initial){ + str->String.StrPtr=StrAlloc(String,&str->String.StrLen,&str->String.ScrLen); + if(!(str->String.StrPtr))return EFI_OUT_OF_RESOURCES; + } else { + str->NewStr.StrPtr=StrAlloc(String,&str->NewStr.StrLen, &str->NewStr.ScrLen); + if(!(str->NewStr.StrPtr))return EFI_OUT_OF_RESOURCES; + } + + str->LangIdx=(UINT32)LangIdx; + //if Token is provided, use it. Otherwise assign new one. + if (Token && *Token) str->Token=*Token; + else + { + str->Token=PHandle->NextStrToken; + PHandle->NextStrToken++; + if (Token) *Token = str->Token; + } + str->Handle=PHandle->Handle; + + return DbeInsert(&gHiiDb.StringDb,(VOID*)str); +} + +EFI_STATUS UpdateString(IN UINTN li, + IN HII_HANDLE *phnd, + IN STRING_REF *Reference, + IN CHAR16 *NewString) +{ + EFI_STATUS Status; + //Check if String with this Token# already present in String Db + if((*Reference)==0){ + Status=AddString(li,phnd,NewString,FALSE,Reference); + if(EFI_ERROR(Status)) return Status; + } else { + HII_STR *str; + if (*Reference >= phnd->NextStrToken) return EFI_INVALID_PARAMETER; + str=LocateString(phnd,li,*Reference); + //if str is NULL, it means that string with this token has been created + //for a different language + Status= (str) ? ReplaceString(str,NewString) : AddString(li,phnd,NewString,FALSE,Reference); + } + return Status; + +} +/////////////////////////////////////////////////////////////////// +EFI_STATUS HiiNewString(IN EFI_HII_PROTOCOL *This, + IN CHAR16 *Language, + IN EFI_HII_HANDLE Handle, + IN STRING_REF *Reference, + IN CHAR16 *NewString) +{ + UINTN li=0, hi=0; + HII_LANG *lang; + HII_HANDLE *phnd; + EFI_STATUS Status=0; + UINT16 dl[4]={0x20,0x20,0x20,0}, *pdl;//Any Lang +//------------------------------- + if(!This || !Reference || !NewString) return EFI_INVALID_PARAMETER; + //first Check if the Handle is valid. + phnd=LocateHandle(Handle,&hi); + if(!phnd) return EFI_INVALID_PARAMETER; + + if(!phnd->HasStr){ + phnd=LocateStrHandleGuid(hi,&hi); + if(!phnd) return EFI_INVALID_PARAMETER; + } + + if(!Language){ + pdl=&dl[0]; + if(EFI_ERROR( GetDefaultLang(pdl))){ + pdl=(UINT16*)gHiiDb.LangDb.Items[phnd->PriLang]; + } + } else pdl=Language; + + //dl has a language string "xxx" + lang=LocateLang(pdl,&li); + + if (!li) + {//language index 0 referes to language " ", which means we have to update + //string for all languages + //update string for primary language + Status = UpdateString(phnd->PriLang,phnd,Reference,NewString); + //update string for all secondary languages + for(li=0; !EFI_ERROR(Status) && li<phnd->SecLang.ItemCount; li++) + Status = UpdateString((UINTN)phnd->SecLang.Items[li],phnd,Reference,NewString); + return Status; + } + + if(!lang) return EFI_INVALID_PARAMETER; + + //If language is valid but not mutch Pack PriLang + if(phnd->PriLang!=li){ + Status=LocateSecLangAdd(phnd,&li,FALSE); + if(EFI_ERROR(Status))li=phnd->PriLang; + //lang=(HII_LANG*)gHiiDb.LangDb.Items[li]; + } + return UpdateString(li,phnd,Reference,NewString); +} + +/////////////////////////////////////////////////////////////////// +EFI_STATUS GetLanguageFromPack(EFI_HII_STRING_PACK *Pack, UINTN *LangIndex){ + UINT16 *sn, *ln; + UINT8 *ofs=(UINT8*)Pack;//(Pack+1); +//------------------------- + sn=(UINT16*)(ofs+Pack->LanguageNameString); + ln=(UINT16*)(ofs+Pack->PrintableLanguageName); + return LocateLangAdd(sn,ln,LangIndex); +} + +/////////////////////////////////////////////////////////////////// +BOOLEAN IsLastStrPack(EFI_HII_STRING_PACK *Pack){ + if(Pack->Header.Type==EFI_HII_STRING && + Pack->Header.Length == 0 && Pack->Attributes == 0 && + Pack->LanguageNameString == 0 && Pack->NumStringPointers == 0 && + Pack->PrintableLanguageName == 0 ) return TRUE; + return FALSE; +} + +/////////////////////////////////////////////////////////////////// +EFI_STATUS HiiGetPrimaryLanguage(IN EFI_HII_PROTOCOL *This, + IN EFI_HII_HANDLE Handle, + OUT EFI_STRING *LanguageString) +{ + HII_HANDLE *phnd; + HII_LANG *lang; + UINTN hi; + UINT16 *ls,*bp; +//---------------------- + if(!This || !LanguageString) return EFI_INVALID_PARAMETER; + + phnd=LocateHandle(Handle,&hi); + if(!phnd) return EFI_INVALID_PARAMETER; + if(!phnd->HasStr){ + phnd=LocateStrHandleGuid(hi,&hi); + if(!phnd) return EFI_INVALID_PARAMETER; + } +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//??????????????????????????????????????? + //if for some reson Somebody submit just IFR vith no Strings + //there are no way to determine language so I just put there 0 -Any Language + //but Intel's code expect me to return something like "eng" + //so I will return Default System Lang. +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO + ls=Malloc(sizeof(UINT16)*3*(phnd->SecLang.ItemCount+1)+1); //4 characters + if(!ls) return EFI_OUT_OF_RESOURCES; + + bp=ls; + lang=gHiiDb.LangDb.Items[phnd->PriLang]; + pBS->CopyMem(ls,&lang->sName,sizeof(UINT16)*3); + bp+=3; + + for(hi=0;hi<phnd->SecLang.ItemCount; hi++){ + lang=gHiiDb.LangDb.Items[(UINTN)phnd->SecLang.Items[hi]]; + pBS->CopyMem(bp,&lang->sName,sizeof(UINT16)*3); + bp+=3; + } + *bp=0; + *LanguageString=ls; + + return EFI_SUCCESS; +} + +/////////////////////////////////////////////////////////////////// +// +EFI_STATUS HiiGetSecondaryLanguages(IN EFI_HII_PROTOCOL *This, + IN EFI_HII_HANDLE Handle, + IN CHAR16 *PrimaryLanguage, + OUT EFI_STRING *LanguageString) +{ + UINTN id,i; + HII_HANDLE *phnd; + HII_LANG *lang; + UINT16 *ls; +//---------------------- + if(!This) return EFI_INVALID_PARAMETER; + + phnd=LocateHandle(Handle,NULL); + if(!phnd) return EFI_INVALID_PARAMETER; + + //Some how caller managed to scrue up with parameters. + lang=LocateLang(PrimaryLanguage,&id);//Lang provided does not mutch with what we've recorded + if( !lang || phnd->PriLang!=id ) return EFI_INVALID_PARAMETER; + + if(phnd->SecLang.ItemCount>0){ + UINT16 *l; + //---------------- + ls=Malloc(sizeof(UINT16)*3*phnd->SecLang.ItemCount+1); + if(!ls) return EFI_OUT_OF_RESOURCES; + l=ls; + for(i=0; i<phnd->SecLang.ItemCount; i++){ + //we are not returning Any Language str " " + //And Any Lang String has index 0 upon initialization + if((UINTN)(phnd->SecLang.Items[i])){ + lang=(HII_LANG*)gHiiDb.LangDb.Items[(UINTN)(phnd->SecLang.Items[i])]; + pBS->CopyMem(l,&lang->sName[0],sizeof(UINT16)*3);//4 unicode chars; + l+=3; + } + }//resulting string will be consist of N*3xUINT16+TERMINATOR + *l=0x0000; //put terminator at the end of set of sec lang + *LanguageString=ls; + }else { *LanguageString=NULL; return EFI_NOT_FOUND;} + return EFI_SUCCESS; +} + +/////////////////////////////////////////////////////////////////// +//This is a worker function to avoid dubliceted code in HiiGetString, +//HiiGetLine and ExtHiiGetStrInfo +HII_STR *GetHiiString(EFI_HII_HANDLE Handle, UINT16 *Lang, STRING_REF Token){ + UINTN li,hi; + UINT16 dl[4]={0x20,0x20,0x20,0}, *pdl; + HII_HANDLE *phnd; + HII_STR *str; +//------------------------------ + phnd=LocateHandle(Handle,&hi); + if(!phnd) return NULL; + + if(!phnd->HasStr){ + phnd=LocateStrHandleGuid(hi,&hi); + if(!phnd) return NULL; + } + + if(!Lang){ + pdl=&dl[0]; + if(EFI_ERROR(GetDefaultLang(pdl)))pdl=(UINT16*)gHiiDb.LangDb.Items[phnd->PriLang]; + } else pdl=Lang; + + //dl has a language string it " " or "xxx" + //lang=LocateLang(pdl,&li); + if(!LocateLang(pdl,&li)) return NULL; + str=LocateString(phnd,li,Token); + + // If String is not found and language is not specified, + // let's try with the primary package language. + if (!str && !Lang) str=LocateString(phnd,0,Token); + + return str; +} + + +/////////////////////////////////////////////////////////////////// +EFI_STATUS HiiGetStringNew(IN EFI_HII_PROTOCOL *This, + IN EFI_HII_HANDLE Handle, + IN STRING_REF Token, + IN BOOLEAN Raw, + IN CHAR16 *LanguageString, + IN OUT UINTN *BufferLength, //in units of UINT16 + OUT EFI_STRING StringBuffer) +{ + HII_STR *str; + UINTN j,i; + UINT16 *ps, sl; +//-------------------------- + + if( !This || !BufferLength || *BufferLength && !StringBuffer ) return EFI_INVALID_PARAMETER; + + str=GetHiiString(Handle,LanguageString,Token); + if(!str) return EFI_INVALID_PARAMETER; + + if(str->NewStr.StrPtr){ + ps=str->NewStr.StrPtr; + sl=str->NewStr.StrLen; + } else { + ps=str->String.StrPtr; + sl=str->String.StrLen; + } + //str->StrLen in UINT16 units + if(*BufferLength<sl*sizeof(UINT16)) { + *BufferLength=sl*sizeof(UINT16); + return EFI_BUFFER_TOO_SMALL; + } + + if(Raw){ + pBS->CopyMem(&StringBuffer[0],ps,sl*sizeof(UINT16)); + *BufferLength=sl*sizeof(UINT16); + } else { + for(i=0,j=0;i<(UINTN)(sl-1);i++){ + //replace <CR> with <Space> + //if(ps[i]==0x0013) + // StringBuffer[j]=0x0020; + //else { + //skip all Special and Control Characters. + if((ps[i]>=0xFFF0 && ps[i]<=0xFFFF)) +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO +//It is amazing how Intel's engineers not in compliance with +//their own Specs. +//"If (Raw) 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." +// ||(ps[i]>=0x0000 && ps[i]<=0x001F)) +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO + continue; + //Copy the rest of chars + else StringBuffer[j]=ps[i]; + //} + j++; + } + StringBuffer[j]=0;//Terminate String!! + *BufferLength=(UINT16)((j+1)*sizeof(UINT16)); + } + return EFI_SUCCESS; +} + +/////////////////////////////////////////////////////////////////// +EFI_STATUS HiiGetStringOld(IN EFI_HII_PROTOCOL *This, + IN EFI_HII_HANDLE Handle, + IN STRING_REF Token, + IN BOOLEAN Raw, + IN CHAR16 *LanguageString, + IN OUT UINT16 *BufferLength, //in units of UINT16 + OUT EFI_STRING StringBuffer) +{ + EFI_STATUS Status; + UINTN bl; +//----------------- + if(BufferLength==NULL) return EFI_INVALID_PARAMETER; + + bl=(UINTN)(*BufferLength); + Status=HiiGetStringNew(This,Handle,Token,Raw,LanguageString,&bl,StringBuffer); + (*BufferLength)=(UINT16)bl; + + if((Status==EFI_BUFFER_TOO_SMALL) && (bl > 0xFFFF)) Status=EFI_INVALID_PARAMETER; + + return Status; +} + + +/////////////////////////////////////////////////////////////////// +EFI_STATUS HiiGetLine(IN EFI_HII_PROTOCOL *This, + IN EFI_HII_HANDLE Handle, + IN STRING_REF Token, + IN OUT UINT16 *Index, + IN UINT16 LineWidth, + IN CHAR16 *LanguageString, + IN OUT UINT16 *BufferLength, + OUT EFI_STRING StringBuffer) +{ + HII_STR *str; + UINTN j,i; + UINT16 *ps, sl; + BOOLEAN cr=FALSE; +//-------------------------- + + if( !This || !BufferLength || !StringBuffer ) return EFI_INVALID_PARAMETER; + + str=GetHiiString(Handle,LanguageString,Token); + if(!str) return EFI_INVALID_PARAMETER; + + if(str->NewStr.StrPtr){ + ps=str->NewStr.StrPtr; + sl=str->NewStr.StrLen; + } else { + ps=str->String.StrPtr; + sl=str->String.StrLen; + } + + //I don't know should I remove a special chars or not + // So I will for now + for(j=0,i=*Index; (i<sl || i<LineWidth); i++ ){ + //replace <CR> with <Space> + if(ps[i]==0x0013){ + if(cr) { //if <CR> hit second time in a row - terminate string + StringBuffer[j]=0x0000; + *Index=(UINT16)i; + break; + } else { //else replece it with space an set "cr" flag + StringBuffer[j]=0x0020; + cr=TRUE; + } + }else{ + cr=FALSE; //if we here - reset "cr" flarg + //skip all Special and Control Characters. + if((ps[i]>=0xFFF0 && ps[i]<=0xFFFF)||(ps[i]<=0x001F)) + continue; //will not increase "j" the buffer index + //Copy the rest of chars into the Buffer + else + StringBuffer[j]=ps[i]; + } + j++; + } + StringBuffer[j]=0;//Terminate String!! + *BufferLength=(UINT16)((j+1)*sizeof(UINT16)); + return EFI_SUCCESS; +} + +/////////////////////////////////////////////////////////////////// +EFI_STATUS HiiResetStrings(IN EFI_HII_PROTOCOL *This, + IN EFI_HII_HANDLE Handle) +{ + HII_STR *str; + UINTN i,hi;//,j,gbi[10],gc=0; + HII_HANDLE *phnd; +//------------------------ + + if(!This) return EFI_INVALID_PARAMETER; + phnd=LocateHandle(Handle,&hi); + if(!phnd) return EFI_INVALID_PARAMETER; + + if(!phnd->HasStr){ + phnd=LocateStrHandleGuid(hi,&hi); + if(!phnd) return EFI_INVALID_PARAMETER; + } + //LocateSameGuidHandle(hi, &gbi[0], &gc); + + //for(j=0; j<=gc; j++){ + for(i=0; i<gHiiDb.StringDb.RecordCount;i++){ + //if(!phnd->HasStr) break; + DbeGoToIndex(&gHiiDb.StringDb,STR_KEY,i,&str); + if(str->Handle==phnd->Handle){ + if(str->NewStr.StrPtr){ + pBS->FreePool(str->NewStr.StrPtr); + str->NewStr.StrPtr=NULL; + str->NewStr.StrLen=0; + str->NewStr.ScrLen=0; + //Cleanup Dtabase from RECORDS which was addes + //after initial Package + if(!str->String.StrPtr){ + DbeDelete(&gHiiDb.StringDb, str, TRUE); + i--;//we ned to step on the same data index + continue; + //since we have delited current one + //phnd->NextStrToken--; + } + + } + } + if(str->Handle>phnd->Handle) break; + } + phnd->NextStrToken=phnd->StrCount; + + // if(j<gc)phnd=gHiiDb.HandleDb.Items[gbi[j]]; + //} + return EFI_SUCCESS; +} + +/////////////////////////////////////////////////////////////////// +EFI_STATUS NewStringPack(IN EFI_HII_STRING_PACK *Package, + UINTN HandleId) +{ + UINTN i,lid; + UINT8 *ofs; + UINT16 *str; + RELOFST *ps;//string pointer + EFI_HII_STRING_PACK *cp=Package; + EFI_STATUS Status=0; + BOOLEAN f=TRUE; + HII_HANDLE *phnd=(HII_HANDLE*)gHiiDb.HandleDb.Items[HandleId]; +//-------------------------------- + while(!IsLastStrPack(cp)){ + ps=(RELOFST*)(cp+1); + ofs=(UINT8*)cp; + //Check if Language exists already + Status=GetLanguageFromPack(cp,&lid); + if(EFI_ERROR(Status)) return Status; + if(f){//if this is first string pack make this lang Primary + phnd->PriLang=(UINT32)lid; + f=FALSE; + } else { + //All other languages if any will be Secondary languages + Status=LocateSecLangAdd(phnd,&lid,TRUE); + if(EFI_ERROR(Status)) return Status; + } + + for(i=0; i<Package->NumStringPointers; i++){ + phnd->NextStrToken=(STRING_REF)i; + if(!ps[i]) continue; + str=(UINT16*)(ofs+ps[i]); + Status=AddString(lid,phnd,str,TRUE,NULL); + if(EFI_ERROR(Status)) return Status; + } + + + cp=(EFI_HII_STRING_PACK*)((UINT8*)cp+cp->Header.Length); + } + phnd->StrCount=(STRING_REF)Package->NumStringPointers; + phnd->HasStr=TRUE; + return Status; +} + + +/////////////////////////////////////////////////////////////////// +// IFR Releated Functions +/////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////// +//this one will calculate length in bytes for the buffer designed +//to receive a copy of form instance +//UINT16 GetFormLen(HII_FORM *Form){ +// HII_LABEL *lbl; +// UINTN i; +// UINT16 len=Form->BufferLength; +//------------------------ +// for(i=0; i<Form->Labels.ItemCount; i++){ +// lbl=Form->Labels.Items[i]; +// if(lbl->Erased) len-=lbl->OrgDataLength; +// len+=lbl->UpdDataLength; +// } +// return len; +//} + +/////////////////////////////////////////////////////////////////// +//this one will calculate length in bytes for the buffer designed +//to receive a copy of FormSet instance +//UINT16 GetFormSetLen(HII_FORMSET *FormSet){ +// UINT16 len=0; +// UINTN i; +// HII_FORM *frm; +//------------------ +// for(i=0; i<FormSet->Forms.ItemCount; i++){ +// frm=FormSet->Forms.Items[i]; +// len+=GetFormLen(frm); +// } +// return len+FormSet->FormSetData->Header.Length+FormSet->EndFormSet->Header.Length; +//} + +UINTN GetDataLen( UINT8 *OpCode, UINTN *Count, BOOLEAN Remove){ + UINTN i; + UINTN len=0; + UINT8 *p=OpCode; +//------------------------ + for(i=0; i<*Count; i++){ +// if( !Remove && +// ( (*p)==EFI_IFR_END_FORM_OP || (*p)==EFI_IFR_LABEL_OP ) +// ){ +// i=i; +// } + if( ( Remove && ( (*p)==EFI_IFR_END_FORM_OP || (*p)==EFI_IFR_LABEL_OP ) +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO + //when adding data I expect that caller knows what he is doing and + //passes me correct Data Count. Guess what? This is not TRUE in Intel's Setup. + //Intel uses Zeroed buffer to fill with desired Opcodes, set Data count to 0xFF and here we go. + //In this case if in buffer we will found junk which satisfy conditions below + //we can seriousely scrue up!!!!! +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO + || ((*p)==0 || (*p)>EFI_IFR_VARSTORE_SELECT_PAIR_OP ))){ + *Count=i; + break; + } + len = len + ((EFI_IFR_OP_HEADER*)p)->Length; + p=OpCode+len; + } + return len; +} + + +/////////////////////////////////////////////////////////////////// +//this will copy form from HII DB private storage to decignated Buffer +VOID CopyForm(UINT8* Buffer, HII_FORM *Form, UINTN *BytesCnt){ + UINTN i,cnt=0; + HII_LABEL *lbl=NULL; + UINT8 *bp=Buffer; +//---------------- + + //Now First Label has data starting from opcode next to FORM_OP + //and lbl->Label of very first label in the list actualy FORM_OP + //so don't need following code + + //if(Form->Labels.ItemCount)lbl=(HII_LABEL*)Form->Labels.Items[0]; + //1. copy form till first label (including LABEL OPCODE) + //if(lbl)//Total Bufferlength including EOF opcode + // cnt=(UINT8*)(lbl->Label)-(UINT8*)Form->FormData; + //else + // cnt=Form->BufferLength-Form->EndForm->Header.Length; + + //pBS->CopyMem(bp,Form->FormData,For); + //bp+=cnt; //Advance buffer pointer; + //(*BytesCnt)=cnt; + (*BytesCnt)=0; + //Keep circling trough Labels copying corresponded data + for(i=0;i<Form->Labels.ItemCount;i++){ + lbl=(HII_LABEL*)Form->Labels.Items[i]; + //copy Label OpCode + pBS->CopyMem(bp,lbl->Label,lbl->Label->Header.Length); + bp+=lbl->Label->Header.Length; + (*BytesCnt)+=lbl->Label->Header.Length; + + //if Label was updated copy Update data first... + if(lbl->LabelData){ + pBS->CopyMem(bp,lbl->LabelData,lbl->DataLength); + bp+=lbl->DataLength; + (*BytesCnt)+=lbl->DataLength; + } + } + //Copy EOF opcode + cnt=Form->EndForm->Header.Length; + pBS->CopyMem(bp,Form->EndForm,cnt); + (*BytesCnt)+=cnt; + return; +} + +/////////////////////////////////////////////////////////////////// +//will copy entire formset data excluding Pcakage Header +VOID CopyFormSet(UINT8* Buffer, HII_FORMSET *FormSet, UINTN *BytesCnt){ + UINTN i; + UINT8 *bp=Buffer,*pp; + UINTN cnt; + HII_FORM *frm; +//---------------- + bp=Buffer; + //Copy Formset OpCode... + pBS->CopyMem(bp,FormSet->FormSetData,FormSet->FormSetData->Header.Length); + bp+=FormSet->FormSetData->Header.Length; + *BytesCnt=FormSet->FormSetData->Header.Length; + //Copy any information that we might have from end of FormSet Opcode + //to the befinning of FOrm OpCode VARSTORE for example. + if(FormSet->Forms.ItemCount){ + pp=(UINT8*)FormSet->FormSetData+FormSet->FormSetData->Header.Length; + frm=FormSet->Forms.Items[0]; + cnt=(UINTN)((UINT8*)frm->FormData-pp); + pBS->CopyMem(bp,pp,cnt); + bp+=cnt; + *BytesCnt+=cnt; + } + + for(i=0; i<FormSet->Forms.ItemCount; i++){ + frm=FormSet->Forms.Items[i]; + CopyForm(bp,frm,&cnt); + bp+=cnt; + *BytesCnt+=cnt; + } + //copy END_OF_FORM_SET OP here + cnt=FormSet->EndFormSet->Header.Length; + pBS->CopyMem(bp,&FormSet->EndFormSet->Header.OpCode,cnt); + *BytesCnt+=cnt; + return; +} + + + +/////////////////////////////////////////////////////////////////// +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO +// Cache Form and Formset +HII_FORM *LocateForm(HII_FORMSET *FormSet, EFI_FORM_ID FormId){ + EFI_STATUS Status=0; + UINTN fid; +//---------------------------------------------- + Status=LocateItem(&FormSet->Forms,&FormId,sizeof(EFI_FORM_ID),&fid); + if(EFI_ERROR(Status)) return NULL; + + return (HII_FORM*)FormSet->Forms.Items[fid]; +} + +/////////////////////////////////////////////////////////////////// +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO +// Cache Form and Formset +HII_FORMSET *LocateFormSet(UINTN HandleIdx, UINTN* FormSetIdx){ + EFI_STATUS Status=0; + UINTN fsid; +//-------------------------- + Status=LocateItem(&gHiiDb.IfrDb,&((UINT32)HandleIdx),sizeof(UINT32),&fsid); + if(EFI_ERROR(Status)) return NULL; + if(FormSetIdx!=NULL)*FormSetIdx=fsid; + return (HII_FORMSET*)gHiiDb.IfrDb.Items[fsid]; +} + + +HII_LABEL *LocateFormLabel(HII_FORM *Form, EFI_FORM_LABEL LabelId, UINTN *LabelIdx){ + EFI_STATUS Status=0; + UINTN lid; +//---------------------------------------------- + Status=LocateItem(&Form->Labels,&LabelId, sizeof(EFI_FORM_LABEL),&lid); + if(EFI_ERROR(Status)) return NULL; + + *LabelIdx=lid; + return (HII_LABEL*)Form->Labels.Items[lid]; +} + +HII_LABEL *LocateFormSetLabel(HII_FORMSET *FormSet, EFI_FORM_LABEL LabelId, UINTN *LabelIdx){ + EFI_STATUS Status=0; + UINTN lid; +//---------------------------------------------- + Status=LocateItem(&FormSet->Labels,&LabelId, sizeof(EFI_FORM_LABEL),&lid); + if(EFI_ERROR(Status)) return NULL; + + if(LabelIdx)*LabelIdx=lid; + return (HII_LABEL*)FormSet->Labels.Items[lid]; +} + + +/////////////////////////////////////////////////////////////////// +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO +//This MUST be here to make Shell working +static UINT8 gDummyVfr[] = { + //Header + 0x2c, 0x00, 0x00, 0x00, //Actual Length of Data Buffer + 0x03, 0x00, //Type; + // start of IFR data + /*O*/ 0x0E, //Opcode=EFI_IFR_FORM_SET_OP + /*L*/ 0x24, //Length + //Offset=8 + /*G*/ 0xBC, 0x30, 0x0C, 0x9E, 0x06, 0x3F, 0xA6, 0x4B, 0x82, 0x88, 0x09, 0x17, 0x9B, 0x85, 0x5D, 0xBE, //GUID + /*S*/ 0x02, 0x00, //FormSet Title + /*S*/ 0x00, 0x00, //Help + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,//Callback + 0x00, 0x00, //Class + 0x00, 0x00, //SubClass + 0x00, 0x00, //NvDataSize + /*O*/ 0x0D, //OpCOde=EFI_IFR_END_FORM_SET_OP + /*L*/ 0x02, +}; +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO +/////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////// +EFI_STATUS HiiGetFormsNew(IN EFI_HII_PROTOCOL *This, + IN EFI_HII_HANDLE Handle, + IN EFI_FORM_ID FormId, + IN OUT UINTN *BufferLength, + OUT UINT8 *Buffer) +{ + UINTN hid; + HII_FORMSET *fs; + HII_FORM *frm; + HII_HANDLE *phnd; + UINTN len; +//-------------------------------------- + if(This==NULL && BufferLength==NULL) return EFI_INVALID_PARAMETER; + //phnd=LocateHandle(Handle, &hid); + //TODO: Felix: by the HII Spec. we should return EFI_INVALID_PARAMETER + //However, Intel Device Manager expects EFI_NOT_FOUND + //(it hangs if it is something else) + phnd=LocateHandle(Handle, &hid); + if(!phnd) return EFI_NOT_FOUND; + + fs=LocateFormSet(hid, NULL); + if(!fs){ + if(!FormId){ + //Technically I must Return NOT_FOUND ERROR but... +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO +//this patch was made to keep Shell working. Shell and HII coexistance is +//based on assumption that "It must be some IFR pack associated with String pack" +//If this statement FALSE Shell will hang in INFINITE LOOP!!!! +//////////////////////////////////////////////////////////////////////// +//this comments I took from Intel's HII Database Driver +// "If someone is passing in a string only, create a dummy IfrPack with a Guid +// to enable future searching of this data." +//////////////////////////////////////////////////////////////////////// + if(*BufferLength< sizeof(gDummyVfr)) { + *BufferLength=sizeof(gDummyVfr); + return EFI_BUFFER_TOO_SMALL; + } + *BufferLength=sizeof(gDummyVfr); + pBS->CopyMem(Buffer,&gDummyVfr[0],sizeof(gDummyVfr)); + //copy handle guid here Shell expect it to mutch with some standart guids + pBS->CopyMem((VOID*)(Buffer+8),(VOID*)&(phnd->Guid),sizeof(EFI_GUID)); + return EFI_SUCCESS; + } else return EFI_NOT_FOUND; +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO + } + + if(!FormId){//we must return whole FormSet + //STUPID SHELL expect me to return formset with EFI_HII_PACK_HEADER + // why? I don't know! + len=fs->BufferLength+sizeof(EFI_HII_PACK_HEADER); + } else { + frm=LocateForm(fs,FormId); + if(!frm) return EFI_NOT_FOUND; + len=frm->BufferLength; + } + + if(*BufferLength<len){ + *BufferLength=len; + return EFI_BUFFER_TOO_SMALL; + } + *BufferLength=len; + + //If "FormId" we must return whole FormSet + if(!FormId){ + //STUPID SHELL expect me to return formset with EFI_HII_PACK_HEADER + //Create it + *((UINT32*)Buffer)=(UINT32)len; + *((UINT16*)(Buffer+4))=3;//IFR Type + CopyFormSet(Buffer+6,fs,&hid); + } + else + CopyForm(Buffer,frm,&hid); + + return EFI_SUCCESS; +} + +/////////////////////////////////////////////////////////////////// +EFI_STATUS HiiGetFormsOld(IN EFI_HII_PROTOCOL *This, + IN EFI_HII_HANDLE Handle, + IN EFI_FORM_ID FormId, + IN OUT UINT16 *BufferLength, + OUT UINT8 *Buffer) +{ + EFI_STATUS Status=0; + UINTN bl; +//-------------------------------- + if(BufferLength==NULL) return EFI_INVALID_PARAMETER; + + bl=(UINTN)(*BufferLength); + Status=HiiGetFormsNew(This,Handle,FormId,&bl,Buffer); + (*BufferLength)=(UINT16)bl; + + if((Status==EFI_BUFFER_TOO_SMALL) && (bl > 0xFFFF)) Status=EFI_INVALID_PARAMETER; + return Status; +} + + +/////////////////////////////////////////////////////////////////// +//Will free all memory blocks associated with Label->Objects structures +VOID DeleteLabelObjects(HII_LABEL *Label){ + UINTN i; + HII_OBJECT *obj; +//------------------ + for(i=0;i<Label->Objects.ItemCount; i++){ + obj=Label->Objects.Items[i]; + ClearItemLst(&obj->Conditions,FALSE); + ClearItemLst(&obj->Options,FALSE); + } + ClearItemLst(&Label->Objects,TRUE); +} + + + +/////////////////////////////////////////////////////////////////// +EFI_STATUS HiiUpdateForm(IN EFI_HII_PROTOCOL *This, + IN EFI_HII_HANDLE Handle, + IN EFI_FORM_LABEL Label, + IN BOOLEAN AddData, + IN EFI_HII_UPDATE_DATA *Data) +{ + EFI_STATUS Status=0; + UINTN hid,lid; + HII_FORMSET *fs; + HII_FORM *frm; + HII_LABEL *lbl; + UINTN len,cnt; + UINT8 *ub; + EFI_IFR_OP_HEADER *op; +//------------------------- + if(!This || !Data ) return EFI_INVALID_PARAMETER; + + if(!LocateHandle(Handle, &hid)) return EFI_INVALID_PARAMETER; + + //Find Formset + fs=LocateFormSet(hid, NULL); + if(!fs) return EFI_INVALID_PARAMETER; + + //Find Label + //FormUpdate= TRUE means just change Form Title!!! + if(Data->FormUpdate){ +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO +//In Intel's HII implementation Data->FormValue field is missing + //Find Form using UPDATE Data +// frm=LocateForm(fs,Data->FormValue); +// if(!frm) return EFI_NOT_FOUND; + //Update Form Title +// frm->FormData->FormTitle=Data->FormTitle; +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO + } + + // + if(Data->DataCount){ + //Find Label + lbl=LocateFormSetLabel(fs, Label, &lid); + if(!lbl) return EFI_NOT_FOUND; + frm=lbl->OwnerForm; + cnt=Data->DataCount; + if(AddData){ + op=(EFI_IFR_OP_HEADER*)&Data->Data; + if(!op->OpCode || !op->Length) return EFI_INVALID_PARAMETER; + //Calculate size of UPDATE data + len=GetDataLen((UINT8*)op,&cnt,FALSE); + ub=Malloc(len+lbl->DataLength); + if(!ub) return EFI_OUT_OF_RESOURCES; + +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO + //Copy Update Data in Private Buffer + pBS->CopyMem(ub,op,len); + //Copy Old Data in same Private Buffer + if(lbl->LabelData)pBS->CopyMem((VOID*)(ub+len),lbl->LabelData,lbl->DataLength); +//for coimpatibility with Intel's setup I've change order in which the chanks of opcodes +// been copied in a new label buffer - New data will be added after the old data + //if(lbl->LabelData)pBS->CopyMem(ub,lbl->LabelData,lbl->DataLength); + //pBS->CopyMem((VOID*)(ub+lbl->DataLength),op,len); +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO + + //Update Buffer parameters in every structure affected by update + lbl->DataLength = lbl->DataLength + len; + lbl->DataCount = lbl->DataCount + Data->DataCount; + if(lbl->Updated && lbl->LabelData)pBS->FreePool(lbl->LabelData); + lbl->LabelData=(EFI_IFR_OP_HEADER*)ub; + fs->BufferLength = fs->BufferLength + len; + frm->BufferLength = frm->BufferLength + len; + //Delete Old Data + DeleteLabelObjects(lbl); + }else{ + //we will not erase an empty Label! + if(lbl->LabelData){ + op=lbl->LabelData; + if(Data->DataCount>=lbl->DataCount){ + cnt=lbl->DataCount; + len=lbl->DataLength; + } else len=GetDataLen((UINT8*)op,&cnt,TRUE); + + //if after erasing no data has left, no need to allocate new buffer + if((INTN)(lbl->DataLength-len)>0){ + ub=Malloc(lbl->DataLength-len); + if(!ub) + return EFI_OUT_OF_RESOURCES; + //Copy rest of Old Data in Private Buffer + pBS->CopyMem(ub,(UINT8*)lbl->LabelData+len,lbl->DataLength-len); + } else ub=NULL; + + //Update Buffer parameters in every structure affected by update + lbl->DataLength = lbl->DataLength - len; + lbl->DataCount = lbl->DataCount - cnt; + if(lbl->Updated && lbl->LabelData)pBS->FreePool(lbl->LabelData); + lbl->LabelData=(EFI_IFR_OP_HEADER*)ub; + fs->BufferLength = fs->BufferLength - len; + frm->BufferLength = frm->BufferLength - len; + DeleteLabelObjects(lbl); + } + } + //Populate pointers on Label Objects from Label Dtat Buffer + if(lbl->LabelData!=NULL)Status=CreateLabelObjects(lbl); + if(EFI_ERROR(Status))return Status; + lbl->Updated=TRUE; + + if(lbl->UpdateCallBack) lbl->UpdateCallBack(Label, Handle,AddData); + } + + if(Data->FormSetUpdate){ + fs->FormSetData->CallbackHandle=Data->FormCallbackHandle; + } + + return EFI_SUCCESS; +} + +EFI_STATUS InitDefStorage(HII_FORMSET *FormSet){ + EFI_STATUS Status; + HII_STORE *st; + static CHAR8 *ss="Setup";//{'S','e','t','u','p',0}; + CHAR8 *pn;//pointer to var name; +//------------------------------------------------ + st=MallocZ(sizeof(HII_STORE)); + if(!st)return EFI_OUT_OF_RESOURCES; + + Status=AppendItemLst(&FormSet->Storages,st); + + st->VarStore=MallocZ(sizeof(EFI_IFR_VARSTORE)+6); + if(!st->VarStore)return EFI_OUT_OF_RESOURCES; + + //Init Default VarStore Structure VarId is Always 0x0000 + st->VarStore->Header.Length=sizeof(EFI_IFR_VARSTORE)+6; + st->VarStore->Header.OpCode=EFI_IFR_VARSTORE_OP; + st->VarStore->Size=FormSet->FormSetData->NvDataSize; + + //Copy formset GUID here + pBS->CopyMem(&st->VarStore->Guid,&FormSet->FormSetData->Guid,sizeof(EFI_GUID)); + + pn=(CHAR8*)st->VarStore; + pn+=sizeof(EFI_IFR_VARSTORE); + pBS->CopyMem(pn,ss,6); + + return EFI_SUCCESS; +} + +//Selects Var Store Object +HII_STORE *LocateStorage(HII_FORMSET *FormSet, UINT16 VarId, UINTN *StoreId OPTIONAL){ + UINTN i; + HII_STORE *st; +//--------------------- + for(i=0; i<FormSet->Storages.ItemCount; i++){ + st=(HII_STORE*)FormSet->Storages.Items[i]; + if(st->VarStore->VarId==VarId) { + if(StoreId)*StoreId=i; + return st; + } + } + return NULL; +} + + +EFI_STATUS CreateLabelObjects(HII_LABEL *Label) +{ + EFI_IFR_OP_HEADER *op; + UINTN i,j=0, k; + HII_OBJECT *obj=NULL; + HII_STORE *st1=NULL, *st2=NULL; + static T_ITEM_LIST clst={0,0,NULL},olst={0,0,NULL}; //temp conditions and objects list list + static T_ITEM_LIST supprstores = {0, 0, NULL}; + EFI_STATUS Status; + BOOLEAN cf=FALSE; //conditions flag + BOOLEAN Suppress = FALSE; +//------------------------------------------- + op=Label->LabelData; + + obj=NULL; + //st1=(HII_STORE*)Label->OwnerForm->Owner->Storages.Items[0]; + st1 = LocateStorage(Label->OwnerForm->Owner, CurrentVarId, NULL); + if(!st1) { st1=(HII_STORE*)Label->OwnerForm->Owner->Storages.Items[0]; CurrentVarId = 0; } + st2=NULL; + for(i=0;i<Label->DataCount;i++){ + //Select Default Storage so Store1 + switch(op->OpCode){ + //Storage Select Opcodes + case EFI_IFR_VARSTORE_SELECT_OP: + { + EFI_IFR_VARSTORE_SELECT *vs=(EFI_IFR_VARSTORE_SELECT*)op; + HII_STORE *st=LocateStorage(Label->OwnerForm->Owner,vs->VarId,NULL); + // preserve the varstore selection - to be reset only by the next varstore select + // or a new formset + //------------------------ + if(st) { st1=st; CurrentVarId = vs->VarId; } + } + break; + case EFI_IFR_VARSTORE_SELECT_PAIR_OP: + { + EFI_IFR_VARSTORE_SELECT_PAIR *v2=(EFI_IFR_VARSTORE_SELECT_PAIR*)op; + HII_STORE *s1=LocateStorage(Label->OwnerForm->Owner,v2->VarId,NULL); + HII_STORE *s2=LocateStorage(Label->OwnerForm->Owner,v2->SecondaryVarId,NULL); + //------------------------ + if(s1) { st1=s1; CurrentVarId = v2->VarId; } + if(s2) st2=s2; + } + break; + //Condition OpCodes + case EFI_IFR_GRAYOUT_IF_OP: + case EFI_IFR_SUPPRESS_IF_OP: + case EFI_IFR_INCONSISTENT_IF_OP: + //if we found some logical expression and local ovject list(olst) has some objects + //we must add this objects with no conditions to the Label->Objects list + //and clear local object list to start fill it with objects who has conditions. + if(!cf){ + for(j=0;j<olst.ItemCount;j++){ + obj=olst.Items[j]; + Status=AppendItemLst(&Label->Objects,obj); + ASSERT(!EFI_ERROR(Status)); + if(EFI_ERROR(Status)) return Status; + } + ClearItemLst(&olst,FALSE); + obj=NULL; + } + cf=TRUE; + if( op->OpCode == EFI_IFR_SUPPRESS_IF_OP) Suppress = TRUE; + else Suppress = FALSE; + /////////////////////////////////////////////////////////////////////// + //Do not add break instruction here it is not present for a reason!!!! + /////////////////////////////////////////////////////////////////////// + case EFI_IFR_AND_OP: + case EFI_IFR_OR_OP: + case EFI_IFR_NOT_OP: + case EFI_IFR_EQ_ID_VAL_OP: + case EFI_IFR_EQ_ID_ID_OP: + case EFI_IFR_EQ_ID_LIST_OP: + case EFI_IFR_EQ_VAR_VAL_OP: + //Add Opcode to the temp Condition list; + Status=AppendItemLst(&clst,op); + ASSERT(!EFI_ERROR(Status)); + if(EFI_ERROR(Status)) return Status;//out of resources + + if(op->OpCode == EFI_IFR_EQ_ID_VAL_OP && Suppress) + { + Status = AppendItemLst(&supprstores, st1); + ASSERT(!EFI_ERROR(Status)); + } + break; + //end of conditions OpCode + case EFI_IFR_END_IF_OP: + //this is definetely end of object presentation, + //but some times it might be no object to add conditions info to + if(!olst.ItemCount){ + for(j=0; j<clst.ItemCount;j++) { + Status=AppendItemLst(&Label->Conditions,clst.Items[j]); + ASSERT(!EFI_ERROR(Status)); + if(EFI_ERROR(Status)) return Status; + } + } + for(j=0;j<olst.ItemCount;j++){ + obj=olst.Items[j]; + //I'm trying to allocate exactly as mutch memory as I need for Conditions.Items[] array. + //If you initialize ItemList.InitialCount with some specific value>0, then next call to + //Append ItemLst function will allocate this number of entries for ItemList.Items[] Array. + obj->Conditions.InitialCount=clst.ItemCount; + Status=AppendItemLst(&obj->Conditions,clst.Items[0]); + ASSERT(!EFI_ERROR(Status)); + if(EFI_ERROR(Status)) return Status; + pBS->CopyMem(&obj->Conditions.Items[1],&clst.Items[1],sizeof(VOID*)*(clst.ItemCount-1)); + obj->Conditions.ItemCount=clst.ItemCount; + for(k = 0; k < supprstores.ItemCount; k++) + { + Status=AppendItemLst(&obj->SuppressStores,supprstores.Items[k]); + ASSERT(!EFI_ERROR(Status)); + if(EFI_ERROR(Status)) return Status; + } + + Status=AppendItemLst(&Label->Objects,obj); + ASSERT(!EFI_ERROR(Status)); + if(EFI_ERROR(Status)) return Status; + } + ClearItemLst(&clst,FALSE); //don't need to free data - it's VFR pointers! + ClearItemLst(&olst,FALSE); + ClearItemLst(&supprstores,FALSE); + obj=NULL; + cf=FALSE; + Suppress = FALSE; + break; + //visual opcodes + case EFI_IFR_SUBTITLE_OP: + case EFI_IFR_TEXT_OP: + case EFI_IFR_INVENTORY_OP: + case EFI_IFR_GRAPHIC_OP: + case EFI_IFR_CHECKBOX_OP: + case EFI_IFR_NUMERIC_OP: + case EFI_IFR_PASSWORD_OP: + case EFI_IFR_REF_OP: + case EFI_IFR_DATE_OP: + case EFI_IFR_TIME_OP: + case EFI_IFR_STRING_OP: + case EFI_IFR_SAVE_DEFAULTS_OP: + case EFI_IFR_RESTORE_DEFAULTS_OP: + case EFI_IFR_HIDDEN_OP: + //continiouse + case EFI_IFR_ONE_OF_OP: + case EFI_IFR_ORDERED_LIST_OP: + ASSERT(!obj); //obj pointer must be cleared when we enter there + if(obj)return EFI_INVALID_PARAMETER; + obj=MallocZ(sizeof(HII_OBJECT)); + ASSERT(obj);//Allocation Problems! + if(!obj) return EFI_OUT_OF_RESOURCES; + obj->ObjectCode=op; + obj->Store1=st1; + obj->Store2=st2; + Status=AppendItemLst(&olst,obj); + ASSERT(!EFI_ERROR(Status)); + if(EFI_ERROR(Status)) return Status; + //in case of DATE or Time opcode advance by 2 opcodes + if(op->OpCode==EFI_IFR_TIME_OP || op->OpCode==EFI_IFR_DATE_OP){ + op=(EFI_IFR_OP_HEADER*)((UINT8*)op+op->Length); + op=(EFI_IFR_OP_HEADER*)((UINT8*)op+op->Length); + i+=2; + } + obj=NULL; + break; + case EFI_IFR_ONE_OF_OPTION_OP: + ASSERT(olst.ItemCount); + if(!olst.ItemCount) return EFI_INVALID_PARAMETER; + obj=(HII_OBJECT*)olst.Items[olst.ItemCount-1]; + if(!obj) return EFI_INVALID_PARAMETER; //obj must be allocated! + Status=AppendItemLst(&obj->Options,op); + ASSERT(!EFI_ERROR(Status)); + if(EFI_ERROR(Status)) return Status;//out of resources + break; + case EFI_IFR_END_ONE_OF_OP: + obj=NULL; + break; + + }//end switch; + //Advance to next opcode + op=(EFI_IFR_OP_HEADER*)((UINT8*)op+op->Length); + } + //If there were no any Condition Opcodes contents of the ObjectList(olst) was not copied to the Label.Objects + for(j=0;j<olst.ItemCount;j++){ + obj=olst.Items[j]; + Status=AppendItemLst(&Label->Objects,obj); + ASSERT(!EFI_ERROR(Status)); + if(EFI_ERROR(Status)) return Status; + } + ClearItemLst(&olst,FALSE); + return EFI_SUCCESS; +} + +//This Routine is called to parse FormVfr and Create Objects which must be shown on the screen; +EFI_STATUS CreateFormObjects(HII_FORM *Form){ + UINTN i; + EFI_STATUS Status = EFI_SUCCESS; +//--------------------------------- + + for(i=0; i<Form->Labels.ItemCount; i++){ + Status=CreateLabelObjects((HII_LABEL*)Form->Labels.Items[i]); + ASSERT(!EFI_ERROR(Status)); + if(EFI_ERROR(Status))return Status; + } + return Status; +} + +EFI_STATUS NewKbdPack(EFI_HII_KEYBOARD_PACK *Package, + UINTN HandleId) +{ + EFI_STATUS Status; + HII_KB_LAYOUT_DATA *kbld; +//-------------------- + //Get Some Memory to accomodate Kb Layout Buffer + kbld=Malloc(sizeof(EFI_KEY_DESCRIPTOR)*Package->DescriptorCount+sizeof(HII_KB_LAYOUT_DATA)); + ASSERT(kbld); + if(kbld==NULL) return EFI_OUT_OF_RESOURCES; + + kbld->HandleIndex=HandleId; //just in case to find HII_HANDLE structure assotiated with this PACK + kbld->KeyDscCount=Package->DescriptorCount; + //We will store KB Layout Data right after the HII_KB_LAYOUT_DATA structure itself + kbld->KeyDsc=(EFI_KEY_DESCRIPTOR*)(kbld+1); + MemCpy((VOID*)kbld->KeyDsc, (VOID*)Package->Descriptor, sizeof(EFI_KEY_DESCRIPTOR)*kbld->KeyDscCount); + + //Add saved KB Layout Data to the HII DB + Status=AppendItemLst((T_ITEM_LIST*)&gHiiDb.KeybdDb.KblInitCount,(VOID*)kbld); + ASSERT_EFI_ERROR(Status); + + //Set recently submitted KB Layout as the current one + gHiiDb.KeybdDb.ActiveLayout=gHiiDb.KeybdDb.KblCount-1; + + return Status; +} + +EFI_STATUS NewIfrPack(EFI_HII_IFR_PACK *Package, + UINTN HandleId) +{ + EFI_STATUS Status; + EFI_IFR_OP_HEADER *op; +// INT32 id=0; + HII_FORM *cf=NULL; + HII_FORMSET *cfs=NULL; + HII_LABEL *cl=NULL; + HII_STORE *st=NULL; + HII_HANDLE *phnd=(HII_HANDLE*)gHiiDb.HandleDb.Items[HandleId]; + UINT8 *p; + BOOLEAN la=FALSE;//label active flag - helps count OPCODES and Label.dLength +//--------------------------------------------- + //Copy Data to a new Storage =(EFI_IFR_OP_HEADER*)(Package+1); + p=Malloc(Package->Header.Length); + if(!p) return EFI_OUT_OF_RESOURCES; + pBS->CopyMem(p,Package,Package->Header.Length); + + op=(EFI_IFR_OP_HEADER*)(p+sizeof(EFI_HII_PACK_HEADER)); + //Parse IFR and crete Working set of data + //Every IFR Pack must start from FORM_SET_OP + while(/*(op->OpCode!=EFI_IFR_END_FORM_SET_OP)||*/((UINTN)op<((UINTN)p)+Package->Header.Length)){ + switch (op->OpCode){ + //Take care of Forms Sets + case EFI_IFR_FORM_SET_OP: + CurrentVarId = 0; + cfs=MallocZ(sizeof(HII_FORMSET)); + if(!cfs) return EFI_OUT_OF_RESOURCES; + //cfs->BufferLength=0; it is 0 + cfs->FormSetData=(EFI_IFR_FORM_SET*)op; + cfs->HandleId=(UINT32)HandleId; + cfs->Handle=phnd->Handle; + //Setup Initial Storage var + Status=InitDefStorage(cfs); + if(EFI_ERROR(Status)) return Status; + break; + case EFI_IFR_VARSTORE_OP: + if(!cfs) return EFI_INVALID_PARAMETER; + st=MallocZ(sizeof(HII_STORE)); + if(!st) return EFI_OUT_OF_RESOURCES; + Status=AppendItemLst(&cfs->Storages,st); + st->VarStore=(EFI_IFR_VARSTORE*)op; + break; + case EFI_IFR_END_FORM_SET_OP: + if(!cfs)return EFI_INVALID_PARAMETER; //found EFI_IFR_END_FORM_SET_OP without EFI_IFR_FORM_SET_OP + //cfs->BufferLength=(UINT16)((UINT8*)op+op->Length-(UINT8*)cfs->FormSetData); + CurrentVarId = 0; + cfs->EndFormSet=(EFI_IFR_END_FORM_SET*)op; + cfs->HandleId=(UINT32)HandleId; + cfs->BufferLength = cfs->BufferLength + op->Length; + Status=AppendItemLst(&gHiiDb.IfrDb,(VOID*)cfs); + if(EFI_ERROR(Status)) return Status; + cfs=NULL; + break; + //Take care of Forms and Labels + case EFI_IFR_FORM_OP: + case EFI_IFR_LABEL_OP: + { + EFI_IFR_OP_HEADER *nxt; + //---------------------------- + if(op->OpCode==EFI_IFR_FORM_OP){ + //it must be some FORM_SET OpCode before we met FORM OpCode + if(!cfs) return EFI_INVALID_PARAMETER; + cf=MallocZ(sizeof(HII_FORM)); + if(!cf) return EFI_OUT_OF_RESOURCES; + //cf->BufferLength=0; + cf->FormData=(EFI_IFR_FORM*)op; + cf->FormId=cf->FormData->FormId; + cf->Owner=cfs; + } + if(!cf && !cfs )return EFI_INVALID_PARAMETER; //Form mus be present + cl=MallocZ(sizeof(HII_LABEL)); + if(!cl) return EFI_OUT_OF_RESOURCES; + + cl->OwnerForm=cf; + cl->Label=(EFI_IFR_LABEL*)op; + //it must be a valid opcode next... + nxt=(EFI_IFR_OP_HEADER*)((UINT8*)op+op->Length); + if(nxt->OpCode!=EFI_IFR_END_FORM_OP && nxt->OpCode!=EFI_IFR_LABEL_OP)cl->LabelData=nxt; + + if(op->OpCode==EFI_IFR_FORM_OP){ + cl->LabelId=0xFACE; //Fake LabelID + } else { + cl->LabelId=cl->Label->LabelId; + Status=AppendItemLst(&cfs->Labels,cl); + if(EFI_ERROR(Status)) return Status; + } + + Status=AppendItemLst(&cf->Labels,cl); + if(EFI_ERROR(Status)) return Status; + + la=TRUE; + } + break; + case EFI_IFR_END_FORM_OP: + if(!cf)return EFI_INVALID_PARAMETER; //found EFI_IFR_END_FORM_OP without EFI_IFR_FORM_OP + //cf->BufferLength=(UINT16)((UINT8*)op+op->Length-(UINT8*)cf->FormData); + cf->EndForm=(EFI_IFR_END_FORM*)op; + cf->BufferLength = cf->BufferLength + op->Length; + Status=AppendItemLst(&cfs->Forms,cf); + if(EFI_ERROR(Status)) return Status; + Status=CreateFormObjects(cf); + cf=NULL; + la=FALSE; + break; + //Labels Has Left + /*case EFI_IFR_LABEL_OP:{ + EFI_IFR_OP_HEADER *nxt; + //--------------------------- + if(!cf && !cfs )return EFI_INVALID_PARAMETER; //Form mus be present + cl=MallocZ(sizeof(HII_LABEL)); + if(!cl) return EFI_OUT_OF_RESOURCES; + + cl->Label=(EFI_IFR_LABEL*)op; + cl->LabelId=cl->Label->LabelId; + cl->OwnerForm=cf; + nxt=(EFI_IFR_OP_HEADER*)(cl->Label+1); + //it must be a valid opcode next... + if(nxt->OpCode!=EFI_IFR_END_FORM_OP && nxt->OpCode!=EFI_IFR_LABEL_OP)cl->LabelData=nxt; + + Status=AppendItemLst(&cf->Labels,cl); + if(EFI_ERROR(Status)) return Status; + + Status=AppendItemLst(&cfs->Labels,cl); + if(EFI_ERROR(Status)) return Status; + la=TRUE; + break; + } + */ + default : + if(la){ + cl->DataCount++; + cl->DataLength = cl->DataLength + op->Length; + } + } //Switch + if(cfs)cfs->BufferLength = cfs->BufferLength + op->Length; + if(cf)cf->BufferLength = cf->BufferLength + op->Length; + op=(EFI_IFR_OP_HEADER*)((UINT8*)op+op->Length); + } + phnd->Ifr=p; + return EFI_SUCCESS; +} + +/////////////////////////////////////////////////////////////////// +// Common Interface functions +/////////////////////////////////////////////////////////////////// +EFI_STATUS HiiNewPackNew(IN EFI_HII_PROTOCOL *This, + IN EFI_HII_PACKAGES *Packages, + OUT EFI_HII_HANDLE *Handle) +{ + UINTN i; + EFI_HII_PACK_HEADER *hdr, **hdrptr; + EFI_STATUS Status=0; + UINTN c=0,hid=0; + HII_HANDLE *phnd=NULL; + BOOLEAN sp=0,vp=0,hp=0; +//----------------------------------------- + if(!This) return EFI_INVALID_PARAMETER; + + hdrptr=(EFI_HII_PACK_HEADER**)(Packages+1); + for(i=0; i<Packages->NumberOfPackages; i++){ + hdr=hdrptr[i]; + switch(hdr->Type){ + case EFI_HII_FONT: + Status=NewFontPack((EFI_HII_FONT_PACK*)hdr); + if(EFI_ERROR(Status)) return Status; + break; + case EFI_HII_STRING: + if(sp)return EFI_INVALID_PARAMETER; + phnd=LocateHandleGuid(Packages->GuidId,&hid); +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO +//this is wrong !!! + //here we are trying to check if somebody using passed GuidId registered Ifr with us + //it should not be like this but Intel's Setup Browser uses same GuidId sor 2 different + //Ifr instances. To maintain compatibility I'll try to patch code... + if(!phnd || phnd->HasStr){ +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO + Status=LocateHandleAdd(gHiiDb.NextHiiHandle,Packages->GuidId,&hid); + if(Status) return Status; + else c++; + phnd=gHiiDb.HandleDb.Items[hid]; + } + Status=NewStringPack((EFI_HII_STRING_PACK*)hdr, hid); + if(EFI_ERROR(Status)) return Status; + sp=TRUE; + break; + case EFI_HII_IFR: + if(vp)return EFI_INVALID_PARAMETER; + phnd=LocateHandleGuid(Packages->GuidId,&hid); +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO +//this is wrong !!!//same goes gor IFR + if(!phnd || phnd->Ifr){ +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO + Status=LocateHandleAdd(gHiiDb.NextHiiHandle,Packages->GuidId,&hid); + if(Status) return Status; + else c++; + phnd=gHiiDb.HandleDb.Items[hid]; + } + + Status=NewIfrPack((EFI_HII_IFR_PACK*)hdr, hid); + if(EFI_ERROR(Status)) return Status; + vp=TRUE; + break; + case EFI_HII_KEYBOARD: + Status=NewKbdPack((EFI_HII_KEYBOARD_PACK*)hdr, hid); + break; + case EFI_HII_HANDLES: + if(hp)return EFI_INVALID_PARAMETER; +//TODO + hp=TRUE; + break; + case EFI_HII_VARIABLE: +//TODO + break; + case EFI_HII_DEVICE_PATH: +//TODO + break; + default: return EFI_INVALID_PARAMETER; + }//switch + } + if(c)gHiiDb.NextHiiHandle++; + + if(phnd)*Handle=phnd->Handle; + else *Handle=0; + + return Status; +} + +EFI_STATUS HiiNewPackOld (IN EFI_HII_PROTOCOL *This, + IN EFI_HII_PACK_LIST *Package, + OUT EFI_HII_HANDLE *Handle) +{ + EFI_STATUS Status=0; + UINTN c=0,hid; + HII_HANDLE *phnd=NULL; +//---------------------------------- + if(!This) return EFI_INVALID_PARAMETER; + + //Check if we have this GUID ib GuidDb already + //For Font and Keyboadr Data HAndle is allways = 0 + if(Package->FontPack) Status=NewFontPack(Package->FontPack); + if(EFI_ERROR(Status)) return Status; + + if(Package->StringPack){ + phnd=LocateHandleGuid(Package->GuidId,&hid); +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO +//this is wrong !!! + //here we are trying to check if somebody using passed GuidId registered Ifr with us + //it should not be like this but Intel's Setup Browser uses same GuidId sor 2 different + //Ifr instances. To maintain compatibility I'll try to patch code... + if(!phnd || phnd->HasStr){ +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO +// if(!phnd){ + Status=LocateHandleAdd(gHiiDb.NextHiiHandle,Package->GuidId,&hid); + if(Status) return Status; + else c++; + phnd=gHiiDb.HandleDb.Items[hid]; + } + + //if(phnd->HasStr) return EFI_INVALID_PARAMETER; + Status=NewStringPack(Package->StringPack, hid); + if(EFI_ERROR(Status)) return Status; + } + + if(Package->IfrPack){ + phnd=LocateHandleGuid(Package->GuidId,&hid); +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO +//this is wrong !!! + //here we are trying to check if somebody using passed GuidId registered Ifr with us + //it should not be like this but Intel's Setup Browser uses same GuidId sor 2 different + //Ifr instances. To maintain compatibility I'll try to patch code... + if(!phnd || phnd->Ifr){ +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO +// if(!phnd){ + Status=LocateHandleAdd(gHiiDb.NextHiiHandle,Package->GuidId,&hid); + if(Status) return Status; + else c++; + phnd=gHiiDb.HandleDb.Items[hid]; + } + + //if(phnd->HasIfr) return EFI_INVALID_PARAMETER; + Status=NewIfrPack(Package->IfrPack, hid); + if(EFI_ERROR(Status)) return Status; + } +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO +//nothing is done for keyboard layout functions +//this is empty spot in spec! +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO + if(c)gHiiDb.NextHiiHandle++; + + if(phnd)*Handle=phnd->Handle; + else *Handle=0; + + return Status; +} + +/////////////////////////////////////////////////////////////////// +//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO//TODO +//this function even not in spec yet so UNSUPPORT it!!! +// here is an explanation I've got from Initial's Source +// "This function allows to extract the NV Image +// that represents the default storage image" +//Still Unclear what to do with it +EFI_STATUS HiiGetDefaultImageOld(IN EFI_HII_PROTOCOL *This, + IN EFI_HII_HANDLE Handle, + IN UINTN DefaultMask, + IN OUT UINT16 *BufferLength, + IN OUT UINT8 *Buffer) +{ + HII_HANDLE *phnd; + HII_FORMSET *fs; + EFI_IFR_OP_HEADER *op; + UINTN hi,fsi,i,t=0,cv=0; + UINT8 *fsb;//formset buffer + BOOLEAN ol=FALSE; + EFI_STATUS Status; +//--------------------------------- + if(!This) return EFI_INVALID_PARAMETER; + + phnd=LocateHandle(Handle,&hi); + if(!phnd || !phnd->Ifr) return EFI_INVALID_PARAMETER; + + fs=LocateFormSet(hi,&fsi); + if(!fs) return EFI_INVALID_PARAMETER; + + if(*BufferLength<fs->FormSetData->NvDataSize){ + *BufferLength=fs->FormSetData->NvDataSize; + return EFI_BUFFER_TOO_SMALL; + } + *BufferLength=fs->FormSetData->NvDataSize; + i=*BufferLength; + + if (DefaultMask & EFI_IFR_FLAG_DEFAULT) + Status=pRS->GetVariable(L"SetupDefaultOverride",&phnd->Guid,NULL,&i,Buffer); + else { + if (DefaultMask & EFI_IFR_FLAG_MANUFACTURING) + Status=pRS->GetVariable(L"SetupManufacturingOverride",&phnd->Guid,NULL,&i,Buffer); + else { + DefaultMask = DefaultMask | EFI_IFR_FLAG_DEFAULT; + Status=pRS->GetVariable(L"Setup",&phnd->Guid,NULL,&i,Buffer); + } + } + + fsb=Malloc(fs->BufferLength); + if(!fsb) return EFI_OUT_OF_RESOURCES; + CopyFormSet(fsb,fs,&i); + + op=(EFI_IFR_OP_HEADER*)fsb; + while(op->OpCode!=EFI_IFR_END_FORM_SET_OP){ + switch(op->OpCode){ + case EFI_IFR_ORDERED_LIST_OP: + ol=TRUE; + i=((EFI_IFR_ONE_OF*)op)->QuestionId; + t=((EFI_IFR_ONE_OF*)op)->Width; + break; + case EFI_IFR_ONE_OF_OP: + ol=FALSE; + i=((EFI_IFR_ONE_OF*)op)->QuestionId; + t=((EFI_IFR_ONE_OF*)op)->Width; + break; + case EFI_IFR_ONE_OF_OPTION_OP:{ + EFI_IFR_ONE_OF_OPTION *ifro=(EFI_IFR_ONE_OF_OPTION*)op; + //----------------- + if(!cv){ + if(ol){ + //pBS->CopyMem(&Buffer[i],&((EFI_IFR_ONE_OF_OPTION*)op)->Value, 1); + pBS->CopyMem(&Buffer[i],&ifro->Value, 1); + i++; + } else { + //if (((EFI_IFR_ONE_OF_OPTION*)op)->Flags & DefaultMask) + // pBS->CopyMem(&Buffer[i],&((EFI_IFR_ONE_OF_OPTION*)op)->Value,t); + if (ifro->Flags & DefaultMask) + pBS->CopyMem(&Buffer[i],&ifro->Value,t); + } + } + } break; + case EFI_IFR_END_OP: + t=0; + break; + case EFI_IFR_CHECKBOX_OP:{ + EFI_IFR_CHECK_BOX *ifrc=(EFI_IFR_CHECK_BOX*)op; + //-------------------- + if(!cv){ + //if(((EFI_IFR_CHECK_BOX*)op)->Flags & DefaultMask) + // Buffer[((EFI_IFR_CHECK_BOX*)op)->QuestionId] = 1; + //else + // Buffer[((EFI_IFR_CHECK_BOX*)op)->QuestionId] = 0; + if(ifrc->Flags & DefaultMask) + Buffer[ifrc->QuestionId] = 1; + else + Buffer[ifrc->QuestionId] = 0; + } + } break; + case EFI_IFR_NUMERIC_OP:{ + EFI_IFR_NUMERIC *ifrn=(EFI_IFR_NUMERIC*)op; + //-------------------------- + //if (!cv)pBS->CopyMem(&Buffer[((EFI_IFR_NUMERIC*)op)->QuestionId], + // &((EFI_IFR_NUMERIC*)op)->Default,((EFI_IFR_NUMERIC*)op)->Width); + if (!cv){ + pBS->CopyMem(&Buffer[ifrn->QuestionId], &ifrn->Default,ifrn->Width); + } + } break; + + case EFI_IFR_VARSTORE_SELECT_OP: + case EFI_IFR_VARSTORE_SELECT_PAIR_OP: + cv=((EFI_IFR_VARSTORE_SELECT*)op)->VarId; + break; + } + op=(EFI_IFR_OP_HEADER*)((UINT8*)op+op->Length); + } + pBS->FreePool(fsb); + return EFI_SUCCESS; +} +/////////////////////////////////////////////////////////////////// +EFI_STATUS HiiFindHandles(IN EFI_HII_PROTOCOL *This, + //spec not says in what units assume, for now, it is in EFI_HII_HANDLE + IN OUT UINT16 *HandleBufferLength, + OUT EFI_HII_HANDLE *Handle) +{ + UINTN i; + HII_HANDLE *hnd; +//------------------------------- + if(!This) return EFI_INVALID_PARAMETER; + + if(*HandleBufferLength<gHiiDb.HandleDb.ItemCount*sizeof(EFI_HII_HANDLE)){ + *HandleBufferLength = (UINT16)gHiiDb.HandleDb.ItemCount*sizeof(EFI_HII_HANDLE); + return EFI_BUFFER_TOO_SMALL; + } + *HandleBufferLength = (UINT16)gHiiDb.HandleDb.ItemCount*sizeof(EFI_HII_HANDLE); + for (i=0; i<gHiiDb.HandleDb.ItemCount; i++){ + hnd=(HII_HANDLE*)gHiiDb.HandleDb.Items[i]; + Handle[i]=hnd->Handle; + } + return EFI_SUCCESS; +} + +/////////////////////////////////////////////////////////////////// +// Will remove all stuff associated with form set on particular handle +// including all Update Data and Free all memory used to store private data +// This function assumes "HandleIdx" is valid. +VOID RemoveFormSet(UINTN HandleIdx){ + HII_FORMSET *fst; + HII_FORM *frm; + HII_LABEL *lbl; + UINTN i,j,fsi; +//-------------------------------- + while(TRUE) { //it might be more then one formset with the same Handle + fst=LocateFormSet(HandleIdx, &fsi); + if(!fst) return; //Not a single form set was registred with this Handle + + for(i=0;i<fst->Forms.ItemCount;i++){ + frm=(HII_FORM*)fst->Forms.Items[i]; + for(j=0;j<frm->Labels.ItemCount;j++){ + lbl=frm->Labels.Items[j]; + DeleteLabelObjects(lbl); + if(lbl->LabelData && lbl->Updated) pBS->FreePool(lbl->LabelData); + } + ClearItemLst(&frm->Labels,TRUE); + } + ClearItemLst(&fst->Labels,FALSE); + ClearItemLst(&fst->Forms,TRUE); + DeleteItemLst(&gHiiDb.IfrDb,fsi,TRUE); + } +} + +/////////////////////////////////////////////////////////////////// +// Will remove all String records associated with "HandleIdx" for +// all languages. This function assumes "HandleIdx" is valid. +VOID RemoveStrings(UINTN HandleIdx){ + HII_HANDLE *hnd=(HII_HANDLE*)gHiiDb.HandleDb.Items[HandleIdx]; + HII_STR *str; + INTN i; +//----------------------- + for(i=0; (UINTN)i<gHiiDb.StringDb.RecordCount; i++){ + DbeGoToIndex(&gHiiDb.StringDb,STR_KEY,(UINTN)i,&str); + if(str->Handle==hnd->Handle){ + if(str->String.StrPtr)pBS->FreePool(str->String.StrPtr); + if(str->NewStr.StrPtr)pBS->FreePool(str->NewStr.StrPtr); + DbeDelete(&gHiiDb.StringDb,str,TRUE); + i--; + continue; + } + if(str->Handle>hnd->Handle) break; + } +} + + +/////////////////////////////////////////////////////////////////// +EFI_STATUS HiiRemovePack(IN EFI_HII_PROTOCOL *This, + IN EFI_HII_HANDLE Handle) + +{ + UINTN hid; + HII_HANDLE *phnd; + HII_FORMSET *fs; + UINTN i; +//-------------------- + if(!This) return EFI_INVALID_PARAMETER; + + //Here we will try to remove Pack from DB + phnd=LocateHandle(Handle,&hid); + if(!phnd) return EFI_INVALID_PARAMETER; + + //So we found requested Handle, now remove all stuff associated with it. + //Remove IFRs + if(phnd->Ifr){ + RemoveFormSet(hid); + pBS->FreePool(phnd->Ifr); + } + //Remove Strings + if(phnd->HasStr)RemoveStrings(hid); + + //Free Items[] buffer if it was allocated + //if no Secondary Languages installed for this HII_HANDLE nothing has to be done + if(phnd->SecLang.ItemCount)ClearItemLst(&phnd->SecLang,FALSE); + + //reindexing remaining formsets to take care of + //removed HII_HANDLE record from HiiDB.HandleDb[] + for(i=0; i<gHiiDb.IfrDb.ItemCount; i++) { + fs=gHiiDb.IfrDb.Items[i]; + if(fs->HandleId>hid) fs->HandleId--; + } + + DeleteItemLst(&gHiiDb.HandleDb, hid, TRUE); + + //The current saved handle might be pointing on the one been removed. + //so reset them to initial values. + mCurHnd=NULL; + mCurLang=NULL; + mCurHid=0; + mCurLid=0; + mCurStr=NULL; + + return EFI_SUCCESS; +} + +/////////////////////////////////////////////////////////////////// +//HelperFunction to calculate size needed to dump the database +//excluding EFI_HII_DATA_TABLE header +UINTN GetHandleExpBuffSize(HII_HANDLE *HiiHandle, UINTN HndIndex){ + UINTN sz=0, i, li=(UINTN)-1; + HII_FORMSET *fs=NULL; + HII_STR *str=NULL; + HII_STORE *st=NULL; +//------------------------------------- + + //This is an order of data structures as provided in Intel's implementation + //DevPath Data stuff Dummy so far just reserve space for DP_PACK and END_OF_DP + sz+=sizeof(EFI_HII_DEVICE_PATH_PACK)+sizeof(EFI_DEVICE_PATH_PROTOCOL); + + //Find Formset we are working with + fs=LocateFormSet(HndIndex, NULL); + + if(!fs) sz+= sizeof(gDummyVfr); //no formset no VAR data just Dummy Formset + else { + //Variable data + for(i=0; i<fs->Storages.ItemCount; i++){ + //-------------------- + st=fs->Storages.Items[i]; + if(st->VarStore->Size){ + UINT8 *p; + UINTN ind = 0, vsize = 0; + UINT16 VarName[256] = {0}; + //--------------------- + sz+=sizeof(EFI_HII_VARIABLE_PACK); + //sz+=st->VarStore->Size; + p=(UINT8*)(st->VarStore+1); + while(*p){ + p++; + vsize+=sizeof(UINT16); + } + vsize+=sizeof(UINT16);//NULL terminator + sz+=vsize; + + p=(UINT8*)(st->VarStore+1); + while(*p && ind < sizeof(VarName)){ + VarName[ind] = (CHAR16)*p; + p++; ind++; + } + vsize=0; + pRS->GetVariable(VarName,&st->VarStore->Guid,NULL,&vsize,NULL); + if(vsize) + sz+=vsize; + else + sz += st->VarStore->Size; + } + } + if(fs->Storages.ItemCount > 0) + sz+=sizeof(EFI_HII_VARIABLE_PACK); // !! added dummy VARIABLE PACK + + //formset data size + sz+=fs->BufferLength+sizeof(EFI_HII_PACK_HEADER);// !! changed to += + } + + //string data size + if(HiiHandle->HasStr){ + for(i=0; i<gHiiDb.StringDb.RecordCount; i++){ + DbeGoToIndex(&gHiiDb.StringDb,STR_KEY,(UINTN)i,&str); + if(str->Handle==HiiHandle->Handle){ + if((li==-1)||(li!=str->LangIdx)){ + li=str->LangIdx; + sz+=sizeof(EFI_HII_STRING_PACK); //new pack for new language + } + //the StrLen stored in UNICODECHAR units + if(str->NewStr.StrPtr)sz+=str->NewStr.StrLen*sizeof(CHAR16)+sizeof(RELOFST); + else sz+=str->String.StrLen*sizeof(CHAR16)+sizeof(RELOFST); + } + if((str->Handle>HiiHandle->Handle)||(i==gHiiDb.StringDb.RecordCount-1)){ + sz+=sizeof(EFI_HII_STRING_PACK);//terminator pack + break; + } + } + } + return sz; +} + + +UINT32 CountStrOfLang(HII_HANDLE *HiiHandle, UINTN StartIdx, UINTN LangIdx ){ + UINTN i; + UINT32 cnt=0; + HII_STR *str; +//---------------------- + for (i=StartIdx; i<gHiiDb.StringDb.RecordCount;i++){ + DbeGoToIndex(&gHiiDb.StringDb,STR_KEY,i,&str); + if(str->Handle==HiiHandle->Handle){ + if(str->LangIdx==LangIdx)cnt++; + else break; + } else break; + } + return cnt; +} + + +VOID ExportHandleData(IN HII_HANDLE *HiiHandle, IN UINTN HndIndex, + IN EFI_HII_DATA_TABLE *DataTbl, IN OUT UINT8 **BufferPointer) +{ + UINTN sz=0, i; + HII_FORMSET *fs; + HII_STR *str; + HII_STORE *st; + UINT8 *p1=*BufferPointer, *p2; + EFI_STATUS Status; +//------------------------------------- + + //This is an order of data structures as provided in Intel's implementation + //DevPath Data stuff Dummy so far END_OF_DP + DataTbl->DevicePathOffset=(UINT32)(p1-(UINT8*)DataTbl); + + ((EFI_HII_DEVICE_PATH_PACK*)p1)->Header.Type=EFI_HII_DEVICE_PATH; + + //points to the space after EFI_HII_DEVICE_PATH_PACK structure + p2=(p1+sizeof(EFI_HII_DEVICE_PATH_PACK)); + + ((EFI_DEVICE_PATH_PROTOCOL*)p2)->Type=0xFF; + ((EFI_DEVICE_PATH_PROTOCOL*)p2)->SubType=0xFF; +// ((EFI_DEVICE_PATH_PROTOCOL*)p2)->Length=0; + ((EFI_DEVICE_PATH_PROTOCOL*)p2)->Length[0]=0; + ((EFI_DEVICE_PATH_PROTOCOL*)p2)->Length[1]=0; + ((EFI_HII_DEVICE_PATH_PACK*)p1)->Header.Length=(UINT32)(p2-p1+sizeof(EFI_DEVICE_PATH_PROTOCOL)); + + p1=p2+sizeof(EFI_DEVICE_PATH_PROTOCOL); + + //Find Formset we are working with + fs=LocateFormSet(HndIndex, NULL); + if(!fs) { + //No formset no VAR data + DataTbl->VariableDataOffset=0; + + //Copy a Dummy formset to be compatible with Intel + DataTbl->IfrDataOffset=(UINT32)(p1-(UINT8*)DataTbl); + + pBS->CopyMem(p1,&gDummyVfr[0],sizeof(gDummyVfr)); + //copy handle guid here Shell expect it to mutch with some standart guids + pBS->CopyMem((VOID*)(p1+8),(VOID*)&HiiHandle->Guid,sizeof(EFI_GUID)); + //Adjust the pointer + p1+=sizeof(gDummyVfr); + } else { + //Variable data + DataTbl->VariableDataOffset=(UINT32)(p1-(UINT8*)DataTbl); + for(i=0; i<fs->Storages.ItemCount; i++){ + //-------------------- + st=fs->Storages.Items[i]; + if(st->VarStore->Size){ + UINT8 *p; + //--------------------- + p2=p1+sizeof(EFI_HII_VARIABLE_PACK); + ((EFI_HII_VARIABLE_PACK*)p1)->Header.Type=EFI_HII_VARIABLE; + //pBS->CopyMem((VOID*)&(((EFI_HII_VARIABLE_PACK*)p1)->VariableGuid), + // &st->VarStore.Guid, sizeof(EFI_GUID)); + + ((EFI_HII_VARIABLE_PACK*)p1)->VariableGuid=st->VarStore->Guid; + ((EFI_HII_VARIABLE_PACK*)p1)->VariableId=st->VarStore->VarId; + + p=(UINT8*)(st->VarStore+1); + while(*p){ + *p2=*p; + p++; + p2+=sizeof(UINT16); + //per spec VariableLength goes in Bytes + ((EFI_HII_VARIABLE_PACK*)p1)->VariableNameLength+=sizeof(UINT16); + } + p2+=sizeof(UINT16); //Null terminaterd + ((EFI_HII_VARIABLE_PACK*)p1)->VariableNameLength+=sizeof(UINT16); + //Copy contents of the variable at present p2 + p=p1+sizeof(EFI_HII_VARIABLE_PACK); + sz=st->VarStore->Size; + Status=pRS->GetVariable((UINT16*)p,&st->VarStore->Guid,NULL,&sz,p2); + + DataTbl->NumberOfVariableData++; + //don't forget to update size of Var Data in Pack Header + ((EFI_HII_VARIABLE_PACK*)p1)->Header.Length=(UINT32)(p2+sz-p1); + + p1=p2+sz; + } + } + if(!DataTbl->NumberOfVariableData)DataTbl->VariableDataOffset=0; + else { // !! Add zero-terminating EFI HII variable + ((EFI_HII_VARIABLE_PACK*)p1)->Header.Type=EFI_HII_VARIABLE; + ((EFI_HII_VARIABLE_PACK*)p1)->Header.Length = sizeof(EFI_HII_VARIABLE_PACK); + p1 += sizeof(EFI_HII_VARIABLE_PACK); + } + //Formset goes data here + DataTbl->IfrDataOffset=(UINT32)(p1-(UINT8*)DataTbl); + p2=p1+sizeof(EFI_HII_PACK_HEADER); + ((EFI_HII_PACK_HEADER*)p1)->Length=(UINT32)fs->BufferLength+sizeof(EFI_HII_PACK_HEADER); + ((EFI_HII_PACK_HEADER*)p1)->Type=EFI_HII_IFR; + + i=0; + CopyFormSet(p2,fs,&i); + p1=p2+i; + } + //If HIIHandle Data don't have Strings make p2==p1 since we are returning p2 value + p2=p1; + //string data goes here + if(HiiHandle->HasStr){ + UINT8 *p=p1; + UINT32 li=(UINTN)-1; + //----------------- + DataTbl->StringDataOffset=(UINT32)(p1-(UINT8*)DataTbl); + for(i=0; i<gHiiDb.StringDb.RecordCount; i++){ + DbeGoToIndex(&gHiiDb.StringDb,STR_KEY,(UINTN)i,&str); + if(str->Handle==HiiHandle->Handle){ + + if((li==-1)||(li!=str->LangIdx)){ + //p1 points on the EFI_HII_STRING_PACK + p1=p; + ((EFI_HII_STRING_PACK*)p1)->Header.Type=EFI_HII_STRING; + DataTbl->NumberOfLanguages++; + //p2 points on the RELOFS array + p2=p1+sizeof(EFI_HII_STRING_PACK); + + li=str->LangIdx; + + ((EFI_HII_STRING_PACK*)p1)->NumStringPointers=CountStrOfLang(HiiHandle,i,li); + //p points on the UnicodeString; + p=p2+((EFI_HII_STRING_PACK*)p1)->NumStringPointers*sizeof(UINT32); + ((EFI_HII_STRING_PACK*)p1)->LanguageNameString=(UINT32)((UINTN)p-(UINTN)p1); + ((EFI_HII_STRING_PACK*)p1)->PrintableLanguageName=((EFI_HII_STRING_PACK*)p1)->LanguageNameString + +4*sizeof(CHAR16); + ((EFI_HII_STRING_PACK*)p1)->Header.Length=sizeof(EFI_HII_STRING_PACK)+ + ((EFI_HII_STRING_PACK*)p1)->NumStringPointers*sizeof(UINT32); + + } + //update offset table + *((UINT32*)p2)=(UINT32)((UINTN)p-(UINTN)p1); + //the StrLen stored in UNICODECHAR units including NULL CHAR16 + if(str->NewStr.StrPtr){ + pBS->CopyMem(p, str->NewStr.StrPtr, str->NewStr.StrLen*sizeof(CHAR16)); + p+=str->NewStr.StrLen*sizeof(CHAR16); + ((EFI_HII_STRING_PACK*)p1)->Header.Length+=str->NewStr.StrLen*sizeof(CHAR16); + } else { + pBS->CopyMem(p, str->String.StrPtr, str->String.StrLen*sizeof(CHAR16)); + p+=str->String.StrLen*sizeof(CHAR16); + ((EFI_HII_STRING_PACK*)p1)->Header.Length+=str->String.StrLen*sizeof(CHAR16); + } + p2+=sizeof(UINT32); + } + //don't forget to put terminator pack at the very end of the string data + if((str->Handle > HiiHandle->Handle) || (i==gHiiDb.StringDb.RecordCount-1)){ + //Create a terminator pack + p1=p; + ((EFI_HII_STRING_PACK*)p1)->Header.Type=EFI_HII_STRING; + p2=p1+sizeof(EFI_HII_STRING_PACK); + break; + } + } + } + + *BufferPointer=p2; + +} + + + +/////////////////////////////////////////////////////////////////// +EFI_STATUS HiiExport(IN EFI_HII_PROTOCOL *This, + IN EFI_HII_HANDLE Handle, + IN OUT UINTN *BufferSize, + OUT VOID *Buffer ) +{ + UINTN sz, i; + HII_HANDLE *phnd=NULL; + EFI_HII_EXPORT_TABLE *expt=NULL; + EFI_HII_DATA_TABLE *cdt=NULL; + UINT8 *bp=NULL; +//---------------- + if(!This) return EFI_INVALID_PARAMETER; + + sz=sizeof(EFI_HII_EXPORT_TABLE); + + //Calculate buffer Size + for(i=0; i<gHiiDb.HandleDb.ItemCount; i++){ + phnd=(HII_HANDLE*)gHiiDb.HandleDb.Items[i]; + if(Handle && Handle!=phnd->Handle) continue; + sz+=GetHandleExpBuffSize(phnd,i) + sizeof(EFI_HII_DATA_TABLE); + } + //Check the buffer size provided + if(sz > *BufferSize){ + *BufferSize=sz; + return EFI_BUFFER_TOO_SMALL; + } + pBS->SetMem(Buffer, sz, 0); + //Export Table + expt=(EFI_HII_EXPORT_TABLE*)Buffer; + if((UINTN)This == (UINTN)&gHiiDb.HiiProtocolOld) expt->Revision=gEfiHiiProtocolGuidOld; + else expt->Revision=gEfiHiiProtocolGuidNew; + + bp=(UINT8*)(expt+1); + + //Start dumping the data + for(i=0 ; i<gHiiDb.HandleDb.ItemCount; i++){ + + phnd=(HII_HANDLE*)gHiiDb.HandleDb.Items[i]; + if(Handle && Handle!=phnd->Handle) continue; + //CurrentDataTable + cdt=(EFI_HII_DATA_TABLE*)bp; + bp+=sizeof(EFI_HII_DATA_TABLE); + + sz=GetHandleExpBuffSize(phnd,i); + + cdt->HiiHandle=phnd->Handle; + cdt->PackageGuid=phnd->Guid; + cdt->DataTableSize=(UINT32)(sz+sizeof(EFI_HII_DATA_TABLE)); + + ExportHandleData(phnd, i, cdt, &bp); +//debug+ just to test how bp gets incremented + ASSERT((UINTN)cdt+sizeof(EFI_HII_DATA_TABLE)+sz==(UINTN)bp); +//debug- + expt->NumberOfHiiDataTables++; + } + + return EFI_SUCCESS; +} + +EFI_STATUS GetVarStoreData(HII_FORMSET *FormSet, HII_STORE *VarData, UINT8* Buffer, UINTN DefaultMask){ + HII_LABEL *lbl; + HII_OBJECT *obj; + HII_FORM *frm; + EFI_IFR_OP_HEADER *op; + UINTN i,x,j,k,offs,len; +//------------------ + + for(i=0; i<FormSet->Forms.ItemCount; i++){ + frm=FormSet->Forms.Items[i]; + for(x=0; x< frm->Labels.ItemCount; x++){ + //iterate trough the Labels to get each HII_OBJECT + lbl=frm->Labels.Items[x]; + for(j=0; j<lbl->Objects.ItemCount; j++){ + //iterate trough the Objects to see if + obj=lbl->Objects.Items[j]; + + if( VarData->VarStore->VarId!=obj->Store1->VarStore->VarId || + MemCmp(&VarData->VarStore->Guid, &obj->Store1->VarStore->Guid, sizeof(EFI_GUID)) + ) continue; + + //we focused at the Object which has the same VarStore Properies as passed "VarData" + //So parse the object to see if it has any default flags set + op=obj->ObjectCode; + switch(op->OpCode){ + + //ONE_OF and ORDERED_LIST has almost the same encoding + case EFI_IFR_ORDERED_LIST_OP: + case EFI_IFR_ONE_OF_OP: + { + EFI_IFR_ONE_OF_OPTION *opt; + //----------------------- + offs=((EFI_IFR_ONE_OF*)op)->QuestionId; + len=((EFI_IFR_ONE_OF*)op)->Width; + +//DEBUG CODE to check if update runs out of bound + if(offs>=VarData->VarStore->Size) { + ASSERT_EFI_ERROR(EFI_BUFFER_TOO_SMALL); + return EFI_BUFFER_TOO_SMALL; + } +//DEBUG CODE to check if update runs out of bound + + for(k=0; k<obj->Options.ItemCount; k++){ + opt=(EFI_IFR_ONE_OF_OPTION*)obj->Options.Items[k]; + //for ORDERED_LIST it would not be any Defaults + if(op->OpCode==EFI_IFR_ORDERED_LIST_OP){ + pBS->CopyMem(&Buffer[offs],&opt->Value, 1); + offs++; + +//DEBUG CODE to check if update runs out of bound + if(offs>=VarData->VarStore->Size) return EFI_BUFFER_TOO_SMALL; +//DEBUG CODE to check if update runs out of bound + + } else { + UINTN f=(UINTN)opt->Flags; + //------------------ + if (f & DefaultMask) { + pBS->CopyMem(&Buffer[offs],&opt->Value,len); + break; + } + } + } + }break; + + case EFI_IFR_CHECKBOX_OP: + { + EFI_IFR_CHECK_BOX *cb=(EFI_IFR_CHECK_BOX*)obj->ObjectCode; + UINTN f=(UINTN)cb->Flags; + //-------------------- + offs=cb->QuestionId; + +//DEBUG CODE to check if update runs out of bound + if(offs>=VarData->VarStore->Size) return EFI_BUFFER_TOO_SMALL; +//DEBUG CODE to check if update runs out of bound + + if(f & DefaultMask) Buffer[offs] = 1; + else Buffer[offs] = 0; + + } break; + + case EFI_IFR_NUMERIC_OP: + { + EFI_IFR_NUMERIC *num =(EFI_IFR_NUMERIC*)obj->ObjectCode; + //-------------------------- + offs=num->QuestionId; + len=num->Width; + +//DEBUG CODE to check if update runs out of bound + if(offs>=VarData->VarStore->Size) return EFI_BUFFER_TOO_SMALL; +//DEBUG CODE to check if update runs out of bound + + pBS->CopyMem(&Buffer[offs],&num->Default,len); + } break; + + } //switch(obj->ObjectCode->Opcode) + + } //for(j) loop + }//for(x) loop + } //for(i) loop + return EFI_SUCCESS; +} + + + +EFI_STATUS HiiGetDefaultImageNew(IN EFI_HII_PROTOCOL *This, + IN EFI_HII_HANDLE Handle, + IN UINTN DefaultMask, + OUT EFI_HII_VARIABLE_PACK_LIST **VariablePackList) +{ + EFI_STATUS Status=EFI_NOT_FOUND; + UINTN i, j, k, hidx, vnl=0, tbsz=0; + HII_HANDLE *phnd; + EFI_HII_VARIABLE_PACK_LIST *vpl, *fvpl=NULL, *pvpl=NULL; + HII_FORMSET *fs; + HII_STORE *st; + UINT8 *pdb, *pnb; +//---------------------------------- + + //Check Parameters + if(This==NULL || VariablePackList==NULL || !Handle ) return EFI_INVALID_PARAMETER; + + //Find the handle + phnd=LocateHandle(Handle, &hidx); + if(phnd==NULL) return EFI_NOT_FOUND; + + //If no VarStores associated with passed Handle will return NULL + *VariablePackList=NULL; + + //If Handle Exists then find a FormSet associated with this Handle + fs=LocateFormSet(hidx, NULL); + //No formset found => no IFR data + if(fs==NULL) return EFI_NOT_FOUND; + + //Collect the Variable data + for(i=0, hidx=0; i<fs->Storages.ItemCount; i++){ + st=fs->Storages.Items[i]; + if(!st->VarStore->Size) continue; + + Status=EFI_SUCCESS; + hidx++; + //get the variable name length in bytes(ASCII) + vnl=st->VarStore->Header.Length-sizeof(EFI_IFR_VARSTORE); + //determine how much memory we need to accomodate + //EFI_VARIABLE_PACK_LIST + EFI_VARIABLE_PACK + VarName + VarData + vpl=MallocZ(sizeof(EFI_HII_VARIABLE_PACK_LIST)+ //EFI_VARIABLE_PACK_LIST + sizeof(EFI_HII_VARIABLE_PACK)+ //EFI_VARIABLE_PACK + (vnl*sizeof(UINT16))+ //EFI_VARIABLE_PACK has VarName in UINT16 + st->VarStore->Size); //Size of actual NV Var Data + + tbsz+=(sizeof(EFI_HII_VARIABLE_PACK_LIST)+ //EFI_VARIABLE_PACK_LIST + sizeof(EFI_HII_VARIABLE_PACK)+ //EFI_VARIABLE_PACK + (vnl*sizeof(UINT16))+ //EFI_VARIABLE_PACK has VarName in UINT16 + st->VarStore->Size); //Size of actual NV Var Data + + if(!vpl) return EFI_OUT_OF_RESOURCES; + + //determine where in VPL buffer Actual VAriable data suppose to start + pdb=(UINT8*)vpl+sizeof(EFI_HII_VARIABLE_PACK_LIST)+sizeof(EFI_HII_VARIABLE_PACK)+(vnl*sizeof(UINT16)); + + GetVarStoreData(fs,st,pdb,DefaultMask); + + //if this is the first structure in the list remember it we must return it's address + if(fvpl==NULL)fvpl=vpl; + //if PreviouseVariablePackList ptr was initialized update pointer to next VPL with current VPL + if(pvpl!=NULL)pvpl->NextVariablePack=vpl; + //reinitialize PreviouseVariablePackList ptr with current VPL pointer + pvpl=vpl; + + //Update context of the VariablePack pointer to the next data byte afer itself(per .92 spec) + vpl->VariablePack = (EFI_HII_VARIABLE_PACK*)(vpl+1); + + //Now fill out fields of HII_VARIABLE_PACK structure + vpl->VariablePack->Header.Type=EFI_HII_VARIABLE; + vpl->VariablePack->Header.Length=(UINT32)(sizeof(EFI_HII_VARIABLE_PACK)+(vnl*sizeof(UINT16))+st->VarStore->Size); + vpl->VariablePack->VariableId=st->VarStore->VarId; + vpl->VariablePack->VariableNameLength=(UINT32)(vnl*sizeof(UINT16)); // per spec length in bytes. + pBS->CopyMem(&vpl->VariablePack->VariableGuid, &st->VarStore->Guid, sizeof(EFI_GUID)); + //now copy Variable name "pdb" points at the befinning of VarName buffer + pdb=(UINT8*)vpl+sizeof(EFI_HII_VARIABLE_PACK_LIST)+sizeof(EFI_HII_VARIABLE_PACK); + pnb=(UINT8*)(st->VarStore+1); + //since in VARIABLE_PACKAGE VAR NAME is UNICODE simple MemCpy wouldn't do. + for(j=0,k=0; j<vnl; j++, k+=2) { + pdb[k]=pnb[j]; + } + } + + //Per Spec we have to dump all data in single buffer. + //Update the IN/OUT parameter + if(tbsz) { + *VariablePackList=Malloc(tbsz); + if(*VariablePackList==NULL) return EFI_OUT_OF_RESOURCES; + } else *VariablePackList=NULL; + vpl=fvpl; + pdb=(UINT8*)(*VariablePackList); + while (vpl){ + //copy Var_PACK_LIST + VARPACK to the Common Buffer + pBS->CopyMem(pdb,vpl,sizeof(EFI_HII_VARIABLE_PACK_LIST)+vpl->VariablePack->Header.Length); + pvpl=(EFI_HII_VARIABLE_PACK_LIST*)pdb; + pvpl->VariablePack=(EFI_HII_VARIABLE_PACK*)(pdb+sizeof(EFI_HII_VARIABLE_PACK_LIST)); + + pdb+=(sizeof(EFI_HII_VARIABLE_PACK_LIST)+vpl->VariablePack->Header.Length); + if(vpl->NextVariablePack!=NULL)pvpl->NextVariablePack=(EFI_HII_VARIABLE_PACK_LIST*)pdb; + + pvpl=vpl; + vpl=vpl->NextVariablePack; + + pBS->FreePool(pvpl); + } + + return Status; +} + + +/////////////////////////////////////////////////////////////////// +//Keyboard +EFI_STATUS HiiGetKeyboardLayout(IN EFI_HII_PROTOCOL *This, + OUT UINT16 *DescriptorCount, + OUT EFI_KEY_DESCRIPTOR *Descriptor) +{ + HII_KB_LAYOUT_DATA *kbld; +//------------------------------- + if(!This) return EFI_INVALID_PARAMETER; + + if(!gHiiDb.KeybdDb.KblCount) return EFI_NOT_FOUND; + + kbld=gHiiDb.KeybdDb.KbLayout[gHiiDb.KeybdDb.ActiveLayout]; + + //we got small buffer + if(*DescriptorCount<kbld->KeyDscCount) { + *DescriptorCount=kbld->KeyDscCount; + return EFI_BUFFER_TOO_SMALL; + } + + MemCpy((VOID*)Descriptor, (VOID*)kbld->KeyDsc, sizeof(EFI_KEY_DESCRIPTOR)*kbld->KeyDscCount); + + return EFI_SUCCESS; +} + + +//////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////// +//EXTENDED HII INTERFACE +//////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////// +EFI_STATUS HiiExtGetStringInfo( + IN EXT_HII_PROTOCOL *This, + IN EFI_HII_HANDLE Handle, + IN STRING_REF Token, + IN CHAR16 *Lang, + OUT EXT_STR_INFO **ExtStrInfo) +{ + HII_STR *str; +//----------------------------------------- + if(!This || !ExtStrInfo ) return EFI_INVALID_PARAMETER; + + str=GetHiiString(Handle,Lang,Token); + if(!str) return EFI_NOT_FOUND; + + if(str->NewStr.StrPtr)*ExtStrInfo=&str->NewStr; + else *ExtStrInfo=&str->String; + + return EFI_SUCCESS; +} + + +EFI_STATUS HiiExtGetFormInfo(IN EXT_HII_PROTOCOL *This, + IN EFI_HII_HANDLE Handle, + IN EFI_FORM_ID FormId, + OUT HII_FORM **ExtFormInfo) +{ + HII_FORM *frm; + UINTN hi; + HII_HANDLE *phnd; + HII_FORMSET *fs; +//----------------------------------------- + if(!This || !ExtFormInfo ) return EFI_INVALID_PARAMETER; + + phnd=LocateHandle(Handle,&hi); + ASSERT(phnd); + if(!phnd)return EFI_NOT_FOUND; + + fs=LocateFormSet(hi,NULL); + ASSERT(fs); + if(!fs)return EFI_NOT_FOUND; + + frm=LocateForm(fs,FormId); + ASSERT(frm); + if(!frm)return EFI_NOT_FOUND; + *ExtFormInfo=frm; + + return EFI_SUCCESS; +} + + +EFI_STATUS HiiExtRegisterLabelUpdateCallback(IN EXT_HII_PROTOCOL *This, + IN EFI_HII_HANDLE Handle, + IN EFI_FORM_LABEL LabelId, + IN HII_LABEL_UPDATE_CALLBACK CallBack) +{ + UINTN hi; + HII_LABEL *lbl; + HII_FORMSET *fs; +//---------------------------------- + if(!This || !CallBack ) return EFI_INVALID_PARAMETER; + + if(!LocateHandle(Handle, &hi)) return EFI_INVALID_PARAMETER; + + //Find Formset + fs=LocateFormSet(hi, NULL); + if(!fs) return EFI_INVALID_PARAMETER; + + lbl=LocateFormSetLabel(fs,LabelId,NULL); + if(!lbl) return EFI_NOT_FOUND; + + lbl->UpdateCallBack=CallBack; + + return EFI_SUCCESS; +} + +EFI_STATUS HiiExtUnregisterLabelUpdateCallback(IN EXT_HII_PROTOCOL *This, + IN EFI_HII_HANDLE Handle, + IN EFI_FORM_LABEL LabelId) +{ + UINTN hi; + HII_LABEL *lbl; + HII_FORMSET *fs; +//---------------------------------- + if(!This) return EFI_INVALID_PARAMETER; + + if(!LocateHandle(Handle, &hi)) return EFI_INVALID_PARAMETER; + + //Find Formset + fs=LocateFormSet(hi, NULL); + if(!fs) return EFI_INVALID_PARAMETER; + + lbl=LocateFormSetLabel(fs,LabelId,NULL); + if(!lbl) return EFI_NOT_FOUND; + + lbl->UpdateCallBack=NULL; + + return EFI_SUCCESS; +} + +EFI_STATUS HiiExtGetFormSetInfo(IN EXT_HII_PROTOCOL *This, + IN UINT16 ClassMask, //if ==0xFFFF all Classes + IN UINT16 SubClass, //if ==0xFFFF all SubClasses + OUT T_ITEM_LIST *FormSetList) +{ + UINTN i; + HII_FORMSET *fs; +//------------------------------ + if(!This || !FormSetList) return EFI_INVALID_PARAMETER; + + //Make sure the list is empty + ClearItemLst(FormSetList,FALSE); + for(i=0; i<gHiiDb.IfrDb.ItemCount;i++){ + fs=gHiiDb.IfrDb.Items[i]; + if(SubClass!=0xFFFF && SubClass!=fs->FormSetData->SubClass) continue; + if((fs->FormSetData->Class & ClassMask)==fs->FormSetData->Class) AppendItemLst(FormSetList,fs); + } + return EFI_SUCCESS; +} + +EFI_STATUS HiiExtGetFormLabels(IN EXT_HII_PROTOCOL *This, + IN EFI_HII_HANDLE Handle, + IN EFI_FORM_ID FormID, + OUT T_ITEM_LIST *LabelList) +{ + UINTN i; + HII_FORMSET *fs; + HII_FORM *frm; + HII_LABEL *lbl; + EFI_STATUS Status; +//----------------------------------------- + if(!This || !LabelList ) return EFI_INVALID_PARAMETER; + + if(!LocateHandle(Handle,&i)) return EFI_INVALID_PARAMETER;; + + fs=LocateFormSet(i,NULL); + ASSERT(fs); + if(!fs)return EFI_NOT_FOUND; + + frm=LocateForm(fs,FormID); + ASSERT(frm); + if(!frm)return EFI_NOT_FOUND; + + ClearItemLst(LabelList,FALSE); + for(i=1;i<frm->Labels.ItemCount;i++){ + lbl=frm->Labels.Items[i]; + Status=AppendItemLst(LabelList,lbl); + ASSERT(!EFI_ERROR(Status)); + if(EFI_ERROR(Status))return Status; + } + return EFI_SUCCESS; +} + + +/////////////////////////////////////////////////////////////////// +//Init All Private Data +EFI_STATUS InitPrivateData(EFI_HANDLE MyImgHandle){ + EFI_STATUS Status=0; + //HII_LANG *al;//any lang +//TEST//TEST//TEST//TEST//TEST//TEST//TEST//TEST//TEST//TEST//TEST//TEST + EFI_HII_PACK_LIST *pl=Malloc(sizeof(EFI_HII_PACK_LIST)); + // {BB2F3C9D-C7A1-4283-8AE2-4F4362990E2E} + static EFI_GUID pguid={ 0xbb2f3c9d, 0xc7a1, 0x4283, 0x8a, 0xe2, 0x4f, 0x43, 0x62, 0x99, 0x0e, 0x2e }; + EFI_HII_HANDLE fph;//,sth; +// UINT16 bl; +// UINT8 *fsb; +//TEST//TEST//TEST//TEST//TEST//TEST//TEST//TEST//TEST//TEST//TEST//TEST +//----------------------------- + pBS->SetMem(&gHiiDb, sizeof(HII_DB),0 ); + + gHiiDb.ImageHandle=MyImgHandle; + gHiiDb.NextHiiHandle=1; //Zero Handle is Invalid it must be 1 based + + //Create Any Langguage Entry - empty string L" " + Status=LocateLangAdd(L" ",L"Any Language",NULL); + if(EFI_ERROR(Status)) return Status; + + //Create and Initialize String Database + gHiiDb.StringDb.KeyCount=STR_KEY_CNT; + gHiiDb.StringDb.InitialCount=STRING_DB_MAX_COUNT; + gHiiDb.StringDb.KeyField=&gStrKey; + gHiiDb.StringDb.MemoryType=EfiBootServicesData; + gHiiDb.StringDb.RecordCount=0; + gHiiDb.StringDb.IndexArray=MallocZ(sizeof(VOID*)*gHiiDb.StringDb.InitialCount*gHiiDb.StringDb.KeyCount); + if(!gHiiDb.StringDb.IndexArray) return EFI_OUT_OF_RESOURCES; + + //Init Protocol Instance here + gHiiDb.HiiProtocolOld.NewPack=HiiNewPackOld; + gHiiDb.HiiProtocolNew.NewPack=HiiNewPackNew; + + gHiiDb.HiiProtocolOld.RemovePack=HiiRemovePack; + gHiiDb.HiiProtocolNew.RemovePack=HiiRemovePack; + + gHiiDb.HiiProtocolOld.FindHandles=HiiFindHandles; + gHiiDb.HiiProtocolNew.FindHandles=HiiFindHandles; + + gHiiDb.HiiProtocolOld.GetDefaultImage=HiiGetDefaultImageOld; + gHiiDb.HiiProtocolNew.GetDefaultImage=HiiGetDefaultImageNew; + + gHiiDb.HiiProtocolOld.TestString=HiiTestString; + gHiiDb.HiiProtocolNew.TestString=HiiTestString; + + gHiiDb.HiiProtocolOld.GetGlyph=HiiGetGlyph; + gHiiDb.HiiProtocolNew.GetGlyph=HiiGetGlyph; + + gHiiDb.HiiProtocolOld.GlyphToBlt=HiiGlyphToBlt; + gHiiDb.HiiProtocolNew.GlyphToBlt=HiiGlyphToBlt; + + gHiiDb.HiiProtocolOld.NewString=HiiNewString; + gHiiDb.HiiProtocolNew.NewString=HiiNewString; + + gHiiDb.HiiProtocolOld.GetPrimaryLanguages=HiiGetPrimaryLanguage; + gHiiDb.HiiProtocolNew.GetPrimaryLanguages=HiiGetPrimaryLanguage; + + gHiiDb.HiiProtocolOld.GetSecondaryLanguages=HiiGetSecondaryLanguages; + gHiiDb.HiiProtocolNew.GetSecondaryLanguages=HiiGetSecondaryLanguages; + + gHiiDb.HiiProtocolOld.GetString=HiiGetStringOld; + gHiiDb.HiiProtocolNew.GetString=HiiGetStringNew; + + gHiiDb.HiiProtocolOld.GetLine=HiiGetLine; + gHiiDb.HiiProtocolNew.GetLine=HiiGetLine; + + gHiiDb.HiiProtocolOld.GetForms=HiiGetFormsOld; + gHiiDb.HiiProtocolNew.GetForms=HiiGetFormsNew; + + gHiiDb.HiiProtocolOld.UpdateForm=HiiUpdateForm; + gHiiDb.HiiProtocolNew.UpdateForm=HiiUpdateForm; + + gHiiDb.HiiProtocolOld.GetKeyboardLayout=HiiGetKeyboardLayout; + gHiiDb.HiiProtocolNew.GetKeyboardLayout=HiiGetKeyboardLayout; + + gHiiDb.HiiProtocolOld.ResetStrings=HiiResetStrings; + gHiiDb.HiiProtocolNew.ResetStrings=HiiResetStrings; + + gHiiDb.HiiProtocolOld.ExportDatabase=HiiExport; + gHiiDb.HiiProtocolNew.ExportDatabase=HiiExport; + + //Now do Extended Hii Interface + gHiiDb.HiiExtProtocol.ExtGetStringInfo=HiiExtGetStringInfo; + gHiiDb.HiiExtProtocol.ExtGetFormInfo=HiiExtGetFormInfo; + gHiiDb.HiiExtProtocol.ExtGetFormsetInfo=HiiExtGetFormSetInfo; + gHiiDb.HiiExtProtocol.ExtRegLblCallBack=HiiExtRegisterLabelUpdateCallback; + gHiiDb.HiiExtProtocol.ExtUnregLblCallBack=HiiExtUnregisterLabelUpdateCallback; + gHiiDb.HiiExtProtocol.ExtGetFormLabels=HiiExtGetFormLabels; + + //------------------------------------ + //init Font Data + pl->FontPack=(EFI_HII_FONT_PACK*)&UsStdNarrowGlyphData; + pl->GuidId=&pguid; + pl->IfrPack=NULL;//(EFI_HII_IFR_PACK*)&FrontPageVfrBin; + pl->KeyboardPack=NULL; + pl->StringPack=NULL;//(EFI_HII_STRING_PACK*)&FrontPageStrings; +///// Load Font Pack +{ +#define FONT_FFS_FILE_GUID { 0xdac2b117, 0xb5fb, 0x4964, { 0xa3, 0x12, 0xd, 0xcc, 0x77, 0x6, 0x1b, 0x9b } } +static EFI_GUID guidFontFile = FONT_FFS_FILE_GUID; + EFI_STATUS Status; + EFI_FIRMWARE_VOLUME_PROTOCOL *pFV; + UINTN DataSize; + EFI_GUID *pSectionGuid = NULL; + UINT32 Authentication; + EFI_HANDLE *pHandle; + UINTN Number,i; + Status = pBS->LocateHandleBuffer(ByProtocol,&guidFV, NULL, &Number, &pHandle); + for(i=0;i<Number; i++) + { + Status=pBS->HandleProtocol(pHandle[i], &guidFV, &pFV); + if (EFI_ERROR(Status)) continue; + pSectionGuid=NULL; + DataSize=0; + Status=pFV->ReadSection ( + pFV,&guidFontFile, + EFI_SECTION_FREEFORM_SUBTYPE_GUID,0, &pSectionGuid, &DataSize, + &Authentication + ); + if (!EFI_ERROR(Status)) + { + pl->FontPack=(EFI_HII_FONT_PACK*)((UINT32*)(pSectionGuid+1)+1); + break; + } + } + Status=HiiNewPackOld((EFI_HII_PROTOCOL*)&gHiiDb.HiiProtocolOld,pl,&fph); + pBS->FreePool(pSectionGuid); +} +//////////////////// + if(EFI_ERROR(Status)) return Status; + +//TEST//TEST//TEST//TEST//TEST//TEST//TEST//TEST//TEST//TEST//TEST//TEST +/* pl->FontPack=NULL; + pl->IfrPack=NULL; + pl->KeyboardPack=NULL; + pl->StringPack=(EFI_HII_STRING_PACK*)&SetupStrings; + + Status=HiiNewPack(&gHiiDb.HiiProtocol,pl,&sth); + if(EFI_ERROR(Status)) return Status; + + fsb=NULL; + bl=0; + Status=HiiGetForms(&gHiiDb.HiiProtocol,fph,0,&bl,fsb); + if(Status==EFI_BUFFER_TOO_SMALL); + else if(EFI_ERROR(Status)) return Status; + fsb=Malloc(bl); + if(!fsb) return EFI_OUT_OF_RESOURCES; + Status=HiiGetForms(&gHiiDb.HiiProtocol,fph,0,&bl,fsb); + + //Now, I'll try to ges some strings from FrontPageDb + { + UINT16 mystr[81]; + EFI_STRING plan, slan; + EFI_IFR_FORM_SET *fs=(EFI_IFR_FORM_SET*)fsb; + UINT32 gb,i=0; + //----------------------------------- + + Status=HiiGetPrimaryLanguage(&gHiiDb.HiiProtocol,fph,&plan); + //it might be more than 1 Sec Lang. + Status=HiiGetSecondaryLanguages(&gHiiDb.HiiProtocol,fph,plan,&slan); + + + bl=80; + + Status=HiiGetString(&gHiiDb.HiiProtocol,fph,fs->FormSetTitle,TRUE,slan,&bl,&mystr[0]); + + Status=HiiGetString(&gHiiDb.HiiProtocol,fph,fs->FormSetTitle,TRUE,plan,&bl,&mystr[0]); + + Status=HiiGetString(&gHiiDb.HiiProtocol,fph,fs->Help,TRUE,slan,&bl,&mystr[0]); + + Status=HiiGetString(&gHiiDb.HiiProtocol,fph,fs->Help,TRUE,plan,&bl,&mystr[0]); + + Status=HiiTestString(&gHiiDb.HiiProtocol,&mystr[0],&i,&gb); + + } + +*/ +//TEST//TEST//TEST//TEST//TEST//TEST//TEST//TEST//TEST//TEST//TEST//TEST + pBS->FreePool(pl); +// +// return pBS->InstallMultipleProtocolInterfaces( gHiiDb.ImageHandle, +// &gEfiHiiProtocolGuid,&gHiiDb.HiiProtocol,NULL,NULL); + return EFI_SUCCESS; +} + +//********************************************************************** +//********************************************************************** +//** ** +//** (C)Copyright 1985-2005, American Megatrends, Inc. ** +//** ** +//** All Rights Reserved. ** +//** ** +//** 6145-F Northbelt Pkwy, Norcross, GA 30071 ** +//** ** +//** Phone: (770)-246-8600 ** +//** ** +//********************************************************************** +//********************************************************************** |