tyler.durden
/
audk
mirror of https://github.com/acidanthera/audk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
audk/EdkCompatibilityPkg/Sample/Tools/Source/HiiPack/IfrParse.c

2534 lines
50 KiB
C
Raw Normal View History

Sync all bug fixes between EDK1.04 and EDK1.06 into EdkCompatibilityPkg. git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@11094 6f19259b-4bc3-4df7-8a09-765794883524
2010-11-26 02:54:49 +01:00
/*++
Copyright (c) 2004 - 2010, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
IfrParse.c
Abstract:
Routines for parsing and managing HII IFR packs.
--*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "Tiano.h"
#include "EfiUtilityMsgs.h"
#include "EfiInternalFormRepresentation.h"
#include "Hii.h"
#include "IfrParse.h"
#include "HiiPack.h"
typedef struct _VARIABLE_STORE_ENTRY {
struct _VARIABLE_STORE_ENTRY *Next;
CHAR8 VarName[MAX_VARIABLE_NAME];
char *VarBuffer;
int VarBufferSize;
EFI_HII_VARIABLE_PACK *VarPack;
int VarPackSize;
} VARIABLE_STORE_ENTRY;
typedef STATUS (*IFR_PARSE_FUNCTION) (IFR_PARSE_CONTEXT * Context);
typedef struct {
INT8 *Name;
INT32 Size;
IFR_PARSE_FUNCTION Parse;
} IFR_PARSE_TABLE_ENTRY;
static
STATUS
IfrParse01 (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse02 (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse03 (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse05 (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse06 (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse07 (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse08 (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse09 (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse0A (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse0B (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse0C (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse0D (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse0E (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse0F (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse10 (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse11 (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse12 (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse13 (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse14 (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse15 (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse16 (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse17 (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse18 (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse19 (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse1A (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse1B (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse1C (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse1D (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse1E (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse1F (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse20 (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse21 (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse22 (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse23 (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse24 (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse25 (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse26 (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse27 (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse28 (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse29 (
IFR_PARSE_CONTEXT *Context
);
static
STATUS
IfrParse2A (
IFR_PARSE_CONTEXT *Context
);
static const IFR_PARSE_TABLE_ENTRY mIfrParseTable[] = {
{
0,
0,
NULL
}, // invalid
{
"EFI_IFR_FORM",
sizeof (EFI_IFR_FORM),
IfrParse01
},
{
"EFI_IFR_SUBTITLE",
sizeof (EFI_IFR_SUBTITLE),
IfrParse02
},
{
"EFI_IFR_TEXT",
-6,
IfrParse03
}, // sizeof (EFI_IFR_TEXT) },
{
"unused 0x04 opcode",
0,
NULL
}, // EFI_IFR_GRAPHIC_OP
{
"EFI_IFR_ONE_OF",
sizeof (EFI_IFR_ONE_OF),
IfrParse05
},
{
"EFI_IFR_CHECK_BOX",
sizeof (EFI_IFR_CHECK_BOX),
IfrParse06
},
{
"EFI_IFR_NUMERIC",
sizeof (EFI_IFR_NUMERIC),
IfrParse07
},
{
"EFI_IFR_PASSWORD",
sizeof (EFI_IFR_PASSWORD),
IfrParse08
},
{
"EFI_IFR_ONE_OF_OPTION",
sizeof (EFI_IFR_ONE_OF_OPTION),
IfrParse09
},
{
"EFI_IFR_SUPPRESS",
sizeof (EFI_IFR_SUPPRESS),
IfrParse0A
},
{
"EFI_IFR_END_FORM",
sizeof (EFI_IFR_END_FORM),
IfrParse0B
},
{
"EFI_IFR_HIDDEN",
sizeof (EFI_IFR_HIDDEN),
IfrParse0C
},
{
"EFI_IFR_END_FORM_SET",
sizeof (EFI_IFR_END_FORM_SET),
IfrParse0D
},
{
"EFI_IFR_FORM_SET",
sizeof (EFI_IFR_FORM_SET),
IfrParse0E
},
{
"EFI_IFR_REF",
sizeof (EFI_IFR_REF),
IfrParse0F
},
{
"EFI_IFR_END_ONE_OF",
sizeof (EFI_IFR_END_ONE_OF),
IfrParse10
},
{
"EFI_IFR_INCONSISTENT",
sizeof (EFI_IFR_INCONSISTENT),
IfrParse11
},
{
"EFI_IFR_EQ_ID_VAL",
sizeof (EFI_IFR_EQ_ID_VAL),
IfrParse12
},
{
"EFI_IFR_EQ_ID_ID",
sizeof (EFI_IFR_EQ_ID_ID),
IfrParse13
},
{
"EFI_IFR_EQ_ID_LIST",
-(int) (sizeof (EFI_IFR_EQ_ID_LIST)),
IfrParse14
},
{
"EFI_IFR_AND",
sizeof (EFI_IFR_AND),
IfrParse15
},
{
"EFI_IFR_OR",
sizeof (EFI_IFR_OR),
IfrParse16
},
{
"EFI_IFR_NOT",
sizeof (EFI_IFR_NOT),
IfrParse17
},
{
"EFI_IFR_END_IF",
sizeof (EFI_IFR_END_IF),
IfrParse18
},
{
"EFI_IFR_GRAYOUT",
sizeof (EFI_IFR_GRAYOUT),
IfrParse19
},
{
"EFI_IFR_DATE",
sizeof (EFI_IFR_DATE) / 3,
IfrParse1A
},
{
"EFI_IFR_TIME",
sizeof (EFI_IFR_TIME) / 3,
IfrParse1B
},
{
"EFI_IFR_STRING",
sizeof (EFI_IFR_STRING),
IfrParse1C
},
{
"EFI_IFR_LABEL",
sizeof (EFI_IFR_LABEL),
IfrParse1D
},
{
"EFI_IFR_SAVE_DEFAULTS",
sizeof (EFI_IFR_SAVE_DEFAULTS),
IfrParse1E
},
{
"EFI_IFR_RESTORE_DEFAULTS",
sizeof (EFI_IFR_RESTORE_DEFAULTS),
IfrParse1F
},
{
"EFI_IFR_BANNER",
sizeof (EFI_IFR_BANNER),
IfrParse20
},
{
"EFI_IFR_INVENTORY",
sizeof (EFI_IFR_INVENTORY),
IfrParse21
},
{
"EFI_IFR_EQ_VAR_VAL_OP",
sizeof (EFI_IFR_EQ_VAR_VAL),
IfrParse22
},
{
"EFI_IFR_ORDERED_LIST_OP",
sizeof (EFI_IFR_ORDERED_LIST),
IfrParse23
},
{
"EFI_IFR_VARSTORE_OP",
-(int) (sizeof (EFI_IFR_VARSTORE)),
IfrParse24
},
{
"EFI_IFR_VARSTORE_SELECT_OP",
sizeof (EFI_IFR_VARSTORE_SELECT),
IfrParse25
},
{
"EFI_IFR_VARSTORE_SELECT_PAIR_OP",
sizeof (EFI_IFR_VARSTORE_SELECT_PAIR),
IfrParse26
},
{
"EFI_IFR_TRUE",
sizeof (EFI_IFR_TRUE),
IfrParse27
},
{
"EFI_IFR_FALSE",
sizeof (EFI_IFR_FALSE),
IfrParse28
},
{
"EFI_IFR_GT",
sizeof (EFI_IFR_GT),
IfrParse29
},
{
"EFI_IFR_GE",
sizeof (EFI_IFR_GE),
IfrParse2A
},
};
#define PARSE_TABLE_ENTRIES (sizeof (mIfrParseTable) / sizeof (mIfrParseTable[0]))
static
STATUS
GetVarStoreInfo (
IFR_PARSE_CONTEXT *Context,
UINT16 VarId,
EFI_GUID **VarStoreGuid,
char **VarStoreName
);
static
void
FreeVarStores (
VOID
);
static
STATUS
CreateVarStore (
EFI_GUID *VarGuid,
CHAR8 *VarName,
int VarStoreSize
);
static
STATUS
SetDefaults (
IFR_PARSE_CONTEXT *Context,
UINT32 MfgDefaults
);
//
// Globals
//
static IFR_PARSE_CONTEXT *mParseContext = NULL;
static VARIABLE_STORE_ENTRY *mVariableStores = NULL;
static int BreakOnOpcodeTag = 0;
static int OpcodeTag = 1;
/*****************************************************************************/
STATUS
IfrParseCheck (
char *Buffer,
long BufferSize
)
/*++
Routine Description:
Check a buffer to ensure that is is parseable IFR
Arguments:
Buffer - pointer to raw IFR bytes
BufferSize - size of IFR pointed to by Buffer
Returns:
STATUS_SUCCESS if successful
STATUS_ERROR otherwise
--*/
{
char *Start;
char *End;
char *Pos;
EFI_IFR_OP_HEADER *OpHeader;
char *FileName;
FileName = "";
//
// Walk the list of IFR statements in the IFR pack
//
Start = Buffer;
Pos = Buffer;
End = Start + BufferSize;
while ((Pos >= Start) && (Pos < End)) {
OpHeader = (EFI_IFR_OP_HEADER *) Pos;
//
// Check range on size
//
if (Pos + OpHeader->Length > End) {
Error (NULL, 0, 0, FileName, "invalid IFR opcode size at offset 0x%X", (int) Pos - (int) Start);
return STATUS_ERROR;
}
if (OpHeader->Length == 0) {
Error (NULL, 0, 0, FileName, "IFR opcode size=0 at offset 0x%X", (int) Pos - (int) Start);
return STATUS_ERROR;
}
//
// See if it's the END_FORMSET opcode
//
if (OpHeader->OpCode == EFI_IFR_END_FORM_SET_OP) {
break;
}
//
// Advance to next IFR statement/opcode
//
Pos += OpHeader->Length;
}
return STATUS_SUCCESS;
}
STATUS
IfrParseInit (
VOID
)
/*++
Routine Description:
Initialize this module for IFR pack parsing
Arguments:
Returns:
STATUS_SUCCESS always
--*/
{
return STATUS_SUCCESS;
}
STATUS
IfrParseEnd (
VOID
)
/*++
Routine Description:
Free up memory allocated during IFR pack parsing done by this module
Arguments:
None
Returns:
STATUS_SUCCESS always
--*/
{
IFR_PARSE_CONTEXT *NextContext;
IFR_PARSE_ENTRY *NextEntry;
//
// Free up the memory from our parse contexts
//
while (mParseContext != NULL) {
while (mParseContext->Ifr != NULL) {
NextEntry = mParseContext->Ifr->Next;
//
// We pointed directly into the user buffer, rather than make
// a copy, so don't free up the bytes.
//
free (mParseContext->Ifr);
mParseContext->Ifr = NextEntry;
}
NextContext = mParseContext->Next;
free (mParseContext->PackHeader);
free (mParseContext);
mParseContext = NextContext;
}
return STATUS_SUCCESS;
}
static
void
FreeVarStores (
VOID
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
None
Returns:
GC_TODO: add return values
--*/
{
VARIABLE_STORE_ENTRY *NextVarStore;
//
// Free up memory from our variable stores
//
while (mVariableStores != NULL) {
if (mVariableStores->VarPack != NULL) {
free (mVariableStores->VarPack);
}
NextVarStore = mVariableStores->Next;
free (mVariableStores);
mVariableStores = NextVarStore;
}
}
/******************************************************************************
FUNCTION: IfrParsePack()
DESCRIPTION: Given a pointer to an IFR pack, parse it to create a linked
list of opcodes and relevant data required for later dumping.
*******************************************************************************/
STATUS
IfrParsePack (
int Handle,
EFI_HII_IFR_PACK *PackHeader,
EFI_GUID *PackageGuid
)
/*++
Routine Description:
Given a pointer to an IFR pack, parse it to create a linked
list of opcodes and relevant data required for later dumping.
Arguments:
Handle - the handle number associated with this IFR pack. It
can be used later to retrieve more info on the particular
pack
PackHeader - pointer to IFR pack to parse
PackageGuid - on input, it comes from the HII data table entry for this pack.
On output, we'll return the IFR formset GUID.
Returns:
STATUS_SUCCESS always
--*/
{
EFI_IFR_OP_HEADER *OpHeader;
IFR_PARSE_CONTEXT *Context;
IFR_PARSE_CONTEXT *TempContext;
IFR_PARSE_ENTRY *IfrEntry;
//
// Initialize our context
//
Context = (IFR_PARSE_CONTEXT *) malloc (sizeof (IFR_PARSE_CONTEXT));
if (Context == NULL) {
Error (NULL, 0, 0, "memory allocation failure", NULL);
return STATUS_ERROR;
}
memset ((void *) Context, 0, sizeof (IFR_PARSE_CONTEXT));
//
// Cache a copy of the input pack so the caller can free their copy
//
Context->PackHeader = (EFI_HII_IFR_PACK *) malloc (PackHeader->Header.Length);
if (Context->PackHeader == NULL) {
Error (NULL, 0, 0, "memory allocation failure", NULL);
free (Context);
return STATUS_ERROR;
}
memcpy (Context->PackHeader, PackHeader, PackHeader->Header.Length);
Context->IfrBufferStart = (char *) (Context->PackHeader + 1);
Context->CurrentPos = Context->IfrBufferStart;
Context->IfrBufferLen = PackHeader->Header.Length - sizeof (EFI_HII_IFR_PACK);
Context->Handle = Handle;
Context->FormsetGuid = &Context->NullGuid;
Context->PackageGuid = *PackageGuid;
//
// Add it to the end of our list
//
if (mParseContext == NULL) {
mParseContext = Context;
} else {
TempContext = mParseContext;
while (TempContext->Next != NULL) {
TempContext = TempContext->Next;
}
TempContext->Next = Context;
}
//
// Walk the opcodes in the pack
//
while
(
(Context->CurrentPos >= Context->IfrBufferStart) &&
(Context->CurrentPos < Context->IfrBufferStart + Context->IfrBufferLen)
) {
OpHeader = (EFI_IFR_OP_HEADER *) Context->CurrentPos;
//
// Allocate a new IFR entry to put in our linked list, then
// point directly to the caller's raw data.
//
IfrEntry = (IFR_PARSE_ENTRY *) malloc (sizeof (IFR_PARSE_ENTRY));
if (IfrEntry == NULL) {
Error (NULL, 0, 0, "memory allocation failure", NULL);
free (Context->PackHeader);
free (Context);
return STATUS_ERROR;
}
memset ((void *) IfrEntry, 0, sizeof (IFR_PARSE_ENTRY));
IfrEntry->Tag = ++OpcodeTag;
if (OpcodeTag == BreakOnOpcodeTag) {
EFI_BREAKPOINT ();
}
IfrEntry->RawIfrHeader = (EFI_IFR_OP_HEADER *) (Context->CurrentPos);
//
// Add this entry to our linked list. If it's not the first, then
// forward the variable store settings from the previous entry.
//
if (Context->LastIfr != NULL) {
IfrEntry->VarStoreGuid1 = Context->LastIfr->VarStoreGuid1;
IfrEntry->VarStoreName1 = Context->LastIfr->VarStoreName1;
IfrEntry->VarStoreGuid2 = Context->LastIfr->VarStoreGuid2;
IfrEntry->VarStoreName2 = Context->LastIfr->VarStoreName2;
Context->LastIfr->Next = IfrEntry;
} else {
Context->Ifr = IfrEntry;
}
Context->LastIfr = IfrEntry;
//
// Switch on the opcode to parse it
//
if (OpHeader->OpCode < PARSE_TABLE_ENTRIES) {
if (mIfrParseTable[OpHeader->OpCode].Parse != NULL) {
mIfrParseTable[OpHeader->OpCode].Parse (Context);
}
} else {
Error (
NULL,
0,
0,
"invalid opcode found in IFR",
"offset=0x%X opcode=0x%02X",
(int) OpHeader - (int) Context->PackHeader,
(int) OpHeader->OpCode
);
free (IfrEntry);
free (Context->PackHeader);
free (Context);
return STATUS_ERROR;
}
//
// If it's the END_FORMSET opcode, then we're done
//
if (OpHeader->OpCode == EFI_IFR_END_FORM_SET_OP) {
break;
}
//
// Advance to next IFR statement/opcode
//
if (OpHeader->Length == 0) {
Error (NULL, 0, 0, "0-length IFR opcode encountered", NULL);
free (IfrEntry);
free (Context->PackHeader);
free (Context);
return STATUS_ERROR;
}
Context->CurrentPos += OpHeader->Length;
}
//
// Return the form GUID.
//
*PackageGuid = *Context->FormsetGuid;
return STATUS_SUCCESS;
}
/******************************************************************************
FUNCTION: GetVarStoreInfo()
DESCRIPTION: IFR contains VARSTORE opcodes to specify where variable data
for following opcodes is supposed to be stored. One VARSTORE statement
allows you to specify the variable store GUID and a key, and another
VARSTORE (select) allows you to specify the key of a VARSTORE statement.
Given the key from a VARSTORE_SELECT statement, go find the corresponding
VARSTORE statement with a matching key and return the varstore GUID and
name. If key == 0, then the variable store is FormsetGuid."Setup"
*******************************************************************************/
static
STATUS
GetVarStoreInfo (
IFR_PARSE_CONTEXT *Context,
UINT16 VarId,
EFI_GUID **VarStoreGuid,
char **VarStoreName
)
/*++
Routine Description:
Get variable store information from an IFR pack for a given variable store ID.
Arguments:
Context - pointer to IFR parse context
VarId - variable store ID referenced by IFR being parsed
VarStoreGuid - outgoing GUID of the variable store corresponding to VarId
VarStoreName - outgoing variable name of variable store corresponding to VarId
Returns:
STATUS_SUCCESS - variable store with matching VarId found, and outoing GUID/Name are valid
STATUS_ERROR - otherwise
--*/
{
IFR_PARSE_ENTRY *Ptr;
EFI_IFR_VARSTORE *VarStore;
if (Context == NULL) {
return STATUS_ERROR;
}
//
// Walk the entire IFR form and find a variable store opcode that
// has a matching variable store ID.
//
for (Ptr = Context->Ifr; Ptr != NULL; Ptr = Ptr->Next) {
if (Ptr->RawIfrHeader->OpCode == EFI_IFR_FORM_SET_OP) {
if (VarId == 0) {
*VarStoreGuid = &((EFI_IFR_FORM_SET *) (Ptr->RawIfrHeader))->Guid;
*VarStoreName = DEFAULT_VARIABLE_NAME;
return STATUS_SUCCESS;
}
} else if (Ptr->RawIfrHeader->OpCode == EFI_IFR_VARSTORE_OP) {
//
// See if it's a variable ID match
//
VarStore = (EFI_IFR_VARSTORE *) Ptr->RawIfrHeader;
if (VarStore->VarId == VarId) {
*VarStoreGuid = &VarStore->Guid;
*VarStoreName = (char *) (VarStore + 1);
return STATUS_SUCCESS;
}
}
}
return STATUS_ERROR;
}
STATUS
IfrSetDefaults (
int MfgDefaults
)
/*++
Routine Description:
Go through all the IFR forms we've parsed so far and create and set variable
defaults.
Arguments:
MfgDefaults - non-zero if manufacturing defaults are desired
Returns:
STATUS_SUCCESS - always
--*/
{
IFR_PARSE_CONTEXT *Context;
//
// First free up any variable stores we've created so far.
//
FreeVarStores ();
for (Context = mParseContext; Context != NULL; Context = Context->Next) {
//
// Call our internal function to handle it
//
SetDefaults (Context, MfgDefaults);
}
return STATUS_SUCCESS;
}
/******************************************************************************/
STATUS
IfrGetIfrPack (
int Handle,
EFI_HII_IFR_PACK **PackHeader,
EFI_GUID *FormsetGuid
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Handle - GC_TODO: add argument description
PackHeader - GC_TODO: add argument description
FormsetGuid - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
IFR_PARSE_CONTEXT *Context;
for (Context = mParseContext; Context != NULL; Context = Context->Next) {
if (Context->Handle == Handle) {
*PackHeader = Context->PackHeader;
memcpy (FormsetGuid, Context->FormsetGuid, sizeof (EFI_GUID));
return STATUS_SUCCESS;
}
}
return STATUS_ERROR;
}
STATUS
IfrReferencesVarPack (
int IfrHandle,
EFI_HII_VARIABLE_PACK *VarPack
)
/*++
Routine Description:
Given an HII handle number (which corrresponds to a handle number passed
in to IfrParsePack()), see if the IFR references the specified variable
pack.
Arguments:
IfrHandle - handle number for the IFR pack to check (passed to IfrParsePack())
VarPack - variable pack to check to see if the IFR references
Returns:
STATUS_SUCCESS if the IFR on the given handle references the variable pack
STATUS_WARNING the IFR does not reference the variable pack
STATUS_ERROR invalid IFR handle
--*/
{
IFR_PARSE_CONTEXT *Context;
char VarName[MAX_VARIABLE_NAME];
IFR_PARSE_ENTRY *ParseEntry;
for (Context = mParseContext; Context != NULL; Context = Context->Next) {
if (Context->Handle == IfrHandle) {
//
// Create an ASCII version of the variable name, since that's what is
// referenced in IFR.
//
sprintf (VarName, "%S", (CHAR16 *) (VarPack + 1));
//
// Walk all the opcodes and see if the IFR references this variable pack
//
for (ParseEntry = Context->Ifr; ParseEntry != NULL; ParseEntry = ParseEntry->Next) {
//
// Check for Name.Guid match for primary IFR variable store
//
if ((strcmp (VarName, ParseEntry->VarStoreName1) == 0) &&
(memcmp (&VarPack->VariableGuid, ParseEntry->VarStoreGuid1, sizeof (EFI_GUID)) == 0)
) {
return STATUS_SUCCESS;
}
//
// Check for Name.Guid match for secondary IFR variable store
//
if ((ParseEntry->VarStoreName2 != NULL) &&
(strcmp (VarName, ParseEntry->VarStoreName2) == 0) &&
(memcmp (&VarPack->VariableGuid, ParseEntry->VarStoreGuid2, sizeof (EFI_GUID)) == 0)
) {
return STATUS_SUCCESS;
}
}
return STATUS_WARNING;
}
}
return STATUS_ERROR;
}
STATUS
IfrGetVarPack (
int VarIndex,
EFI_HII_VARIABLE_PACK **VarPack
)
/*++
Routine Description:
Get the variable defaults. It is expected that the caller
called IfrSetDefaults() previously to walk all the IFR forms we know about
and create and initialize default values.
Arguments:
VarIndex - a 0-based index into all the variable stores we know about
VarPack - outgoing pointer to a variable pack
Returns:
STATUS_ERROR - VarIndex exceeds the number of variable packs we know of
STATUS_SUCCESS - otherwise
--*/
{
VARIABLE_STORE_ENTRY *Entry;
//
// Initialize outgoing parameters
//
*VarPack = NULL;
for (Entry = mVariableStores; Entry != NULL; Entry = Entry->Next) {
if (VarIndex == 0) {
*VarPack = Entry->VarPack;
return STATUS_SUCCESS;
}
VarIndex--;
}
return STATUS_ERROR;
}
static
STATUS
SetVariableValue (
EFI_GUID *VarGuid,
char *VarName,
int VarOffset,
int VarSize,
void *VarValue
)
/*++
Routine Description:
Given a variable GUID.Name, offset, size, and value, set the bytes in
the variable to the provided value.
Arguments:
VarGuid - GUID of variable to set
VarName - name of variable to set
VarOffset - byte offset into the variable store
VarSize - size of the value in the variable store (in bytes)
VarValue - pointer to buffer containing the value to set
Returns:
--*/
{
VARIABLE_STORE_ENTRY *Entry;
char *Src;
char *Dest;
//
// Go through our list of variable stores to find the match
//
for (Entry = mVariableStores; Entry != NULL; Entry = Entry->Next) {
if (memcmp (VarGuid, &Entry->VarPack->VariableGuid, sizeof (EFI_GUID)) == 0) {
if (strcmp (VarName, Entry->VarName) == 0) {
//
// Found match -- check offset. If it's beyond the size of the variable store
// buffer, then return a warning. Note that date-time can be beyond the
// end of the varstore, which is ok.
//
if (VarOffset + VarSize <= Entry->VarBufferSize) {
//
// Stuff the data
//
Dest = Entry->VarBuffer + VarOffset;
Src = (char *) VarValue;
while (VarSize > 0) {
*Dest = *Src;
Src++;
Dest++;
VarSize--;
}
return STATUS_SUCCESS;
}
return STATUS_WARNING;
}
}
}
return STATUS_ERROR;
}
static
STATUS
SetDefaults (
IFR_PARSE_CONTEXT *Context,
UINT32 MfgDefaults
)
/*++
Routine Description:
Set variable defaults by walking a single IFR form.
Arguments:
Context - Pointer to the IFR context.
MfgDefaults - Number of Mfg defaults
Returns:
EFI_INVALID_PARAMETER - arguments to function are invalid
STATUS_SUCCESS - function executed successfully
--*/
{
int Size;
int CachedVarOffset;
int CachedVarSize;
int OrderedList;
IFR_PARSE_ENTRY *SavedParseEntry;
EFI_IFR_CHECK_BOX *IfrCheckBox;
EFI_IFR_ONE_OF_OPTION *IfrOneOfOption;
EFI_IFR_NUMERIC *IfrNumeric;
STATUS Status;
char ZeroByte;
//
// Walk the opcodes to set default values and stuff them into the variable stores
//
if (Context == NULL) {
return EFI_INVALID_PARAMETER;
}
Status = STATUS_SUCCESS;
Context->CurrentIfr = Context->Ifr;
SavedParseEntry = NULL;
OrderedList = 0;
CachedVarOffset = 0;
CachedVarSize = 0;
ZeroByte = 0;
while (Context->CurrentIfr != NULL) {
if (Context->CurrentIfr->RawIfrHeader->OpCode == EFI_IFR_FORM_SET_OP) {
//
// Formset opcode -- create a variable pack
//
Status = CreateVarStore (
&((EFI_IFR_FORM_SET *) (Context->CurrentIfr->RawIfrHeader))->Guid,
DEFAULT_VARIABLE_NAME,
((EFI_IFR_FORM_SET *) (Context->CurrentIfr->RawIfrHeader))->NvDataSize
);
} else if (Context->CurrentIfr->RawIfrHeader->OpCode == EFI_IFR_VARSTORE_OP) {
//
// Variable store opcode -- create a variable pack
//
Status = CreateVarStore (
&((EFI_IFR_VARSTORE *) (Context->CurrentIfr->RawIfrHeader))->Guid,
(char *) Context->CurrentIfr->RawIfrHeader + sizeof (EFI_IFR_VARSTORE),
((EFI_IFR_VARSTORE *) (Context->CurrentIfr->RawIfrHeader))->Size
);
} else if (Context->CurrentIfr->RawIfrHeader->OpCode == EFI_IFR_ONE_OF_OP) {
//
// Need this parse context later when we find the default ONE_OF_OPTION.
// Clear out the variable store first, so that we're covered if someone
// has two one-of opcode that operate on the same data.
// So "last one wins" is the behavior.
//
OrderedList = 0;
SavedParseEntry = Context->CurrentIfr;
CachedVarOffset = ((EFI_IFR_ONE_OF *) Context->CurrentIfr->RawIfrHeader)->QuestionId;
CachedVarSize = ((EFI_IFR_ONE_OF *) Context->CurrentIfr->RawIfrHeader)->Width;
} else if (Context->CurrentIfr->RawIfrHeader->OpCode == EFI_IFR_ORDERED_LIST_OP) {
//
// Need this parse context later as we parse the ONE_OF_OP's in the ordered list
//
OrderedList = 1;
SavedParseEntry = Context->CurrentIfr;
CachedVarOffset = ((EFI_IFR_ORDERED_LIST *) Context->CurrentIfr->RawIfrHeader)->QuestionId;
CachedVarSize = ((EFI_IFR_ORDERED_LIST *) Context->CurrentIfr->RawIfrHeader)->MaxEntries;
while (CachedVarSize > 0) {
Status = SetVariableValue (
SavedParseEntry->VarStoreGuid1, // GUID of variable store to write
SavedParseEntry->VarStoreName1, // name of variable store to write
CachedVarOffset, // offset into variable store
1, // variable data size
(void *) &ZeroByte
);
//
// variable value
//
CachedVarSize--;
CachedVarOffset++;
}
CachedVarOffset = ((EFI_IFR_ORDERED_LIST *) Context->CurrentIfr->RawIfrHeader)->QuestionId;
CachedVarSize = 1;
//
// ((EFI_IFR_ORDERED_LIST *)Context->CurrentIfr->RawIfrHeader)->Width;
//
} else if (Context->CurrentIfr->RawIfrHeader->OpCode == EFI_IFR_ONE_OF_OPTION_OP) {
IfrOneOfOption = (EFI_IFR_ONE_OF_OPTION *) Context->CurrentIfr->RawIfrHeader;
//
// If we're in an ordered list, then copy the value to the data store
//
if (OrderedList) {
Status = SetVariableValue (
SavedParseEntry->VarStoreGuid1, // GUID of variable store to write
SavedParseEntry->VarStoreName1, // name of variable store to write
CachedVarOffset, // offset into variable store
1, // variable data size
(void *) &IfrOneOfOption->Value
);
//
// variable value
//
// Advance the offset for the next ordered list item
//
CachedVarOffset += CachedVarSize;
} else {
//
// ONE-OF list. See if the default flag is set (provided we're not doing mfg defaults)
//
if (!MfgDefaults) {
if (IfrOneOfOption->Flags & EFI_IFR_FLAG_DEFAULT) {
Status = SetVariableValue (
SavedParseEntry->VarStoreGuid1, // GUID of variable store to write
SavedParseEntry->VarStoreName1, // name of variable store to write
CachedVarOffset, // offset into variable store
CachedVarSize, // variable data size
&IfrOneOfOption->Value
);
//
// variable value
//
}
} else {
if (IfrOneOfOption->Flags & EFI_IFR_FLAG_MANUFACTURING) {
Status = SetVariableValue (
SavedParseEntry->VarStoreGuid1, // GUID of variable store to write
SavedParseEntry->VarStoreName1, // name of variable store to write
CachedVarOffset, // offset into variable store
CachedVarSize, // variable data size
&IfrOneOfOption->Value
);
//
// variable value
//
}
}
}
} else if (Context->CurrentIfr->RawIfrHeader->OpCode == EFI_IFR_CHECKBOX_OP) {
//
// If we're saving defaults, and the default flag is set, or we're saving
// manufacturing defaults and the manufacturing flag is set, then save a 1.
// By default the varstore buffer is cleared, so we don't need to save a 0 ever.
//
IfrCheckBox = (EFI_IFR_CHECK_BOX *) Context->CurrentIfr->RawIfrHeader;
if (((MfgDefaults == 0) && (IfrCheckBox->Flags & EFI_IFR_FLAG_DEFAULT)) ||
((MfgDefaults != 0) && (IfrCheckBox->Flags & EFI_IFR_FLAG_MANUFACTURING))
) {
Size = 1;
Status = SetVariableValue (
Context->CurrentIfr->VarStoreGuid1, // GUID of variable store to write
Context->CurrentIfr->VarStoreName1, // name of variable store to write
IfrCheckBox->QuestionId, // offset into variable store
IfrCheckBox->Width, // variable data size
(void *) &Size
);
//
// variable value
//
}
} else if (Context->CurrentIfr->RawIfrHeader->OpCode == EFI_IFR_NUMERIC_OP) {
IfrNumeric = (EFI_IFR_NUMERIC *) Context->CurrentIfr->RawIfrHeader;
Status = SetVariableValue (
Context->CurrentIfr->VarStoreGuid1, // GUID of variable store to write
Context->CurrentIfr->VarStoreName1, // name of variable store to write
IfrNumeric->QuestionId, // offset into variable store
IfrNumeric->Width, // variable data size
(void *) &IfrNumeric->Default
);
//
// variable value
//
}
Context->CurrentIfr = Context->CurrentIfr->Next;
}
return STATUS_SUCCESS;
}
static
STATUS
CreateVarStore (
EFI_GUID *VarGuid,
CHAR8 *VarName,
int VarStoreSize
)
/*++
Routine Description:
Given a variable GUID.Name and the size of the variable store, allocate
storage for maintaining the variable value.
Arguments:
VarGuid - GUID for a variable
VarName - Name of the variable
VarStoreSize - size of the variable store
Returns:
STATUS_ERROR - problem with storage allocation
STATUS_SUCCESS - function executed successfully
--*/
{
VARIABLE_STORE_ENTRY *Entry;
VARIABLE_STORE_ENTRY *TempEntry;
int PackSize;
int VarNameLen;
//
// If the variable store size is zero, then do nothing. This could be valid
// if variable steering is used in the IFR such that FormsetGUID."Setup" variable
// store is never used.
//
// OPEN: What about a form that only has a time/date question? Then if some other
// function called SetDefaults(), attempting to set time/date would result in an
// error in the SetVarValue() function.
//
if (VarStoreSize == 0) {
return STATUS_SUCCESS;
}
//
// Go through our list of variable stores and see if we've already created one
// for this Guid.Name. If so, check the size and return. Otherwise create
// one and add it to the list.
//
for (Entry = mVariableStores; Entry != NULL; Entry = Entry->Next) {
if (memcmp (VarGuid, &Entry->VarPack->VariableGuid, sizeof (EFI_GUID)) == 0) {
if (strcmp (VarName, Entry->VarName) == 0) {
//
// Already have one. Check size.
//
if (Entry->VarBufferSize != VarStoreSize) {
Error (NULL, 0, 0, "mismatched variable store size between two formsets", VarName);
return STATUS_ERROR;
}
return STATUS_SUCCESS;
}
}
}
//
// Create a new one.
//
Entry = (VARIABLE_STORE_ENTRY *) malloc (sizeof (VARIABLE_STORE_ENTRY));
if (Entry == NULL) {
Error (NULL, 0, 0, "memory allocation failure", NULL);
return STATUS_ERROR;
}
memset ((void *) Entry, 0, sizeof (VARIABLE_STORE_ENTRY));
//
// Compute size of the varpack
//
VarNameLen = strlen (VarName) + 1;
PackSize = sizeof (EFI_HII_VARIABLE_PACK) + VarNameLen * sizeof (CHAR16) + VarStoreSize;
Entry->VarPack = (EFI_HII_VARIABLE_PACK *) malloc (PackSize);
if (Entry->VarPack == NULL) {
Error (NULL, 0, 0, "memory allocation failure", NULL);
free (Entry);
return STATUS_ERROR;
}
Entry->VarPack->Header.Length = PackSize;
Entry->VarPack->Header.Type = EFI_HII_VARIABLE;
Entry->VarPack->VariableNameLength = VarNameLen * sizeof (CHAR16);
Entry->VarName[MAX_VARIABLE_NAME - 1] = 0;
strncpy (Entry->VarName, VarName, MAX_VARIABLE_NAME - 1);
#ifdef USE_VC8
swprintf ((CHAR16 *) (Entry->VarPack + 1), (strlen (VarName) + 1) * sizeof (CHAR16), L"%S", VarName);
#else
swprintf ((CHAR16 *) (Entry->VarPack + 1), L"%S", VarName);
#endif
memcpy (&Entry->VarPack->VariableGuid, VarGuid, sizeof (EFI_GUID));
//
// Point VarBuffer into the allocated buffer (for convenience)
//
Entry->VarBuffer = (char *) Entry->VarPack + sizeof (EFI_HII_VARIABLE_PACK) + VarNameLen * sizeof (CHAR16);
memset ((void *) Entry->VarBuffer, 0, VarStoreSize);
Entry->VarBufferSize = VarStoreSize;
//
// Add this new varstore to our list
//
if (mVariableStores == NULL) {
mVariableStores = Entry;
} else {
for (TempEntry = mVariableStores; TempEntry->Next != NULL; TempEntry = TempEntry->Next)
;
TempEntry->Next = Entry;
}
return STATUS_SUCCESS;
}
/******************************************************************************/
/*++
Routine Description:
The following IfrParseXX() functions are used to parse an IFR opcode numbered
XX via a dispatch table.
Arguments:
Context - IFR parsing context into which pertinent data for the
current opcode can be saved. Context->LastIfr->RawIfrHeader points to
the raw IFR bytes currently being parsed.
Returns:
STATUS_SUCCESS - always
--*/
/*******************************************************************************/
static
STATUS
IfrParse01 (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse02 (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse03 (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
//
// Parse the IFR EFI_IFR_ONE_OF opcode.
//
static
STATUS
IfrParse05 (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse06 (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse07 (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse08 (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse09 (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse0A (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse0B (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse0C (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse0D (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse0E (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
EFI_IFR_FORM_SET *Op;
Op = (EFI_IFR_FORM_SET *) Context->LastIfr->RawIfrHeader;
Context->LastIfr->VarStoreGuid1 = &Op->Guid;
Context->LastIfr->VarStoreName1 = "Setup";
Context->FormsetGuid = &Op->Guid;
return STATUS_SUCCESS;
}
static
STATUS
IfrParse0F (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse10 (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse11 (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse12 (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse13 (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse14 (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse15 (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse16 (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse17 (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse18 (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse19 (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse1A (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse1B (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse1C (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse1D (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse1E (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse1F (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse20 (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse21 (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse22 (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse23 (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
//
// EFI_IFR_VARSTORE
//
static
STATUS
IfrParse24 (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
EFI_IFR_VARSTORE *Op;
Op = (EFI_IFR_VARSTORE *) Context->LastIfr->RawIfrHeader;
return STATUS_SUCCESS;
}
//
// VARSTORE_SELECT
//
static
STATUS
IfrParse25 (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
STATUS Status;
EFI_IFR_VARSTORE_SELECT *Op;
Op = (EFI_IFR_VARSTORE_SELECT *) Context->LastIfr->RawIfrHeader;
Status = GetVarStoreInfo (Context, Op->VarId, &Context->LastIfr->VarStoreGuid1, &Context->LastIfr->VarStoreName1);
//
// VARSTORE_SELECT sets both
//
Context->LastIfr->VarStoreGuid2 = Context->LastIfr->VarStoreGuid1;
Context->LastIfr->VarStoreName2 = Context->LastIfr->VarStoreName1;
return Status;
}
//
// VARSTORE_SELECT_PAIR
//
static
STATUS
IfrParse26 (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
STATUS Status;
EFI_IFR_VARSTORE_SELECT_PAIR *Op;
Op = (EFI_IFR_VARSTORE_SELECT_PAIR *) Context->LastIfr->RawIfrHeader;
Status = GetVarStoreInfo (Context, Op->VarId, &Context->LastIfr->VarStoreGuid1, &Context->LastIfr->VarStoreName1);
Status = GetVarStoreInfo (
Context,
Op->SecondaryVarId,
&Context->LastIfr->VarStoreGuid2,
&Context->LastIfr->VarStoreName2
);
return Status;
}
//
// TRUE
//
static
STATUS
IfrParse27 (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
//
// FALSe
//
static
STATUS
IfrParse28 (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse29 (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}
static
STATUS
IfrParse2A (
IFR_PARSE_CONTEXT *Context
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Context - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
return STATUS_SUCCESS;
}