[mirror_edk2.git] / MdePkg / Library / IfrSupportLib / UefiIfrOpCodeCreation.c

/** @file

Copyright (c) 2007, Intel Corporation
All rights reserved. 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:

  UefiIfrOpCodeCreation.c

Abstract:

  Library Routines to create IFR independent of string data - assume tokens already exist
  Primarily to be used for exporting op-codes at a label in pre-defined forms.

Revision History:


**/

#include "UefiIfrLibraryInternal.h"

STATIC
BOOLEAN
IsValidQuestionFlags (
  IN UINT8                   Flags
  )
{
  return (BOOLEAN) ((Flags & (~QUESTION_FLAGS)) ? FALSE : TRUE);
}

STATIC
BOOLEAN
IsValidValueType (
  IN UINT8                   Type
  )
{
  return (BOOLEAN) ((Type <= EFI_IFR_TYPE_OTHER) ? TRUE : FALSE);
}

STATIC
BOOLEAN
IsValidNumricFlags (
  IN UINT8                   Flags
  )
{
  if (Flags & ~(EFI_IFR_NUMERIC_SIZE | EFI_IFR_DISPLAY)) {
    return FALSE;
  }

  if ((Flags & EFI_IFR_DISPLAY) > EFI_IFR_DISPLAY_UINT_HEX) {
    return FALSE;
  }

  return TRUE;
}

STATIC
BOOLEAN
IsValidCheckboxFlags (
  IN UINT8                   Flags
  )
{
  return (BOOLEAN) ((Flags <= EFI_IFR_CHECKBOX_DEFAULT_MFG) ? TRUE : FALSE);
}

EFI_STATUS
EFIAPI
CreateEndOpCode (
  IN OUT EFI_HII_UPDATE_DATA *Data
  )
{
  EFI_IFR_END                 End;
  UINT8                       *LocalBuffer;

  ASSERT (Data != NULL && Data->Data != NULL);

  if (Data->Offset + sizeof (EFI_IFR_END) > Data->BufferSize) {
    return EFI_BUFFER_TOO_SMALL;
  }

  End.Header.Length  = sizeof (EFI_IFR_END);
  End.Header.OpCode  = EFI_IFR_END_OP;
  End.Header.Scope   = 0;

  LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
  CopyMem (LocalBuffer, &End, sizeof (EFI_IFR_END));
  Data->Offset += sizeof (EFI_IFR_END);

  return EFI_SUCCESS;
}

EFI_STATUS
EFIAPI
CreateDefaultOpCode (
  IN     EFI_IFR_TYPE_VALUE  *Value,
  IN     UINT8               Type,
  IN OUT EFI_HII_UPDATE_DATA *Data
  )
{
  EFI_IFR_DEFAULT            Default;
  UINT8                      *LocalBuffer;

  ASSERT (Data != NULL && Data->Data != NULL);

  if ((Value == NULL) || !IsValidValueType (Type)) {
    return EFI_INVALID_PARAMETER;
  }

  if (Data->Offset + sizeof (EFI_IFR_DEFAULT) > Data->BufferSize) {
    return EFI_BUFFER_TOO_SMALL;
  }

  Default.Header.OpCode = EFI_IFR_DEFAULT_OP;
  Default.Header.Length = sizeof (EFI_IFR_DEFAULT);
  Default.Header.Scope  = 0;
  Default.Type          = Type;
  Default.DefaultId     = EFI_HII_DEFAULT_CLASS_STANDARD;
  CopyMem (&Default.Value, Value, sizeof(EFI_IFR_TYPE_VALUE));

  LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
  CopyMem (LocalBuffer, &Default, sizeof (EFI_IFR_DEFAULT));
  Data->Offset += sizeof (EFI_IFR_DEFAULT);

  return EFI_SUCCESS;
}

EFI_STATUS
EFIAPI
CreateActionOpCode (
  IN     EFI_QUESTION_ID      QuestionId,
  IN     EFI_STRING_ID        Prompt,
  IN     EFI_STRING_ID        Help,
  IN     UINT8                QuestionFlags,
  IN     EFI_STRING_ID        QuestionConfig,
  IN OUT EFI_HII_UPDATE_DATA  *Data
  )
{
  EFI_IFR_ACTION              Action;
  UINT8                       *LocalBuffer;

  ASSERT (Data != NULL && Data->Data != NULL);

  if (!IsValidQuestionFlags (QuestionFlags)) {
    return EFI_INVALID_PARAMETER;
  }

  if (Data->Offset + sizeof (EFI_IFR_ACTION) > Data->BufferSize) {
    return EFI_BUFFER_TOO_SMALL;
  }

  Action.Header.OpCode          = EFI_IFR_ACTION_OP;
  Action.Header.Length          = sizeof (EFI_IFR_ACTION);
  Action.Header.Scope           = 0;
  Action.Question.QuestionId    = QuestionId;
  Action.Question.Header.Prompt = Prompt;
  Action.Question.Header.Help   = Help;
  Action.Question.VarStoreId    = INVALID_VARSTORE_ID;
  Action.Question.Flags         = QuestionFlags;
  Action.QuestionConfig         = QuestionConfig;

  LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
  CopyMem (LocalBuffer, &Action, sizeof (EFI_IFR_ACTION));
  Data->Offset += sizeof (EFI_IFR_ACTION);

  return EFI_SUCCESS;
}

EFI_STATUS
EFIAPI
CreateSubTitleOpCode (
  IN      EFI_STRING_ID       Prompt,
  IN      EFI_STRING_ID       Help,
  IN      UINT8               Flags,
  IN      UINT8               Scope,
  IN OUT EFI_HII_UPDATE_DATA  *Data
  )
{
  EFI_IFR_SUBTITLE            Subtitle;
  UINT8                       *LocalBuffer;

  ASSERT (Data != NULL && Data->Data != NULL);

  if (Data->Offset + sizeof (EFI_IFR_SUBTITLE) > Data->BufferSize) {
    return EFI_BUFFER_TOO_SMALL;
  }

  Subtitle.Header.OpCode    = EFI_IFR_SUBTITLE_OP;
  Subtitle.Header.Length    = sizeof (EFI_IFR_SUBTITLE);
  Subtitle.Header.Scope     = Scope;
  Subtitle.Statement.Prompt = Prompt;
  Subtitle.Statement.Help   = Help;
  Subtitle.Flags            = Flags;

  LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
  CopyMem (LocalBuffer, &Subtitle, sizeof (EFI_IFR_SUBTITLE));
  Data->Offset += sizeof (EFI_IFR_SUBTITLE);

  return EFI_SUCCESS;
}


EFI_STATUS
EFIAPI
CreateTextOpCode (
  IN     EFI_STRING_ID        Prompt,
  IN     EFI_STRING_ID        Help,
  IN     EFI_STRING_ID        TextTwo,
  IN OUT EFI_HII_UPDATE_DATA  *Data
  )
{
  EFI_IFR_TEXT                Text;
  UINT8                       *LocalBuffer;

  ASSERT (Data != NULL && Data->Data != NULL);

  if (Data->Offset + sizeof (EFI_IFR_TEXT) > Data->BufferSize) {
    return EFI_BUFFER_TOO_SMALL;
  }

  Text.Header.OpCode    = EFI_IFR_TEXT_OP;
  Text.Header.Length    = sizeof (EFI_IFR_TEXT);
  Text.Header.Scope     = 0;
  Text.Statement.Prompt = Prompt;
  Text.Statement.Help   = Help;
  Text.TextTwo          = TextTwo;

  LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
  CopyMem (LocalBuffer, &Text, sizeof (EFI_IFR_TEXT));
  Data->Offset += sizeof (EFI_IFR_TEXT);

  return EFI_SUCCESS;
}

EFI_STATUS
EFIAPI
CreateGotoOpCode (
  IN     EFI_FORM_ID          FormId,
  IN     EFI_STRING_ID        Prompt,
  IN     EFI_STRING_ID        Help,
  IN     UINT8                QuestionFlags,
  IN     EFI_QUESTION_ID      QuestionId,
  IN OUT EFI_HII_UPDATE_DATA  *Data
  )
{
  EFI_IFR_REF                 Goto;
  UINT8                       *LocalBuffer;

  ASSERT (Data != NULL && Data->Data != NULL);

  if (!IsValidQuestionFlags (QuestionFlags)) {
    return EFI_INVALID_PARAMETER;
  }

  if (Data->Offset + sizeof (EFI_IFR_REF) > Data->BufferSize) {
    return EFI_BUFFER_TOO_SMALL;
  }

  Goto.Header.OpCode          = EFI_IFR_REF_OP;
  Goto.Header.Length          = sizeof (EFI_IFR_REF);
  Goto.Header.Scope           = 0;
  Goto.Question.Header.Prompt = Prompt;
  Goto.Question.Header.Help   = Help;
  Goto.Question.VarStoreId    = INVALID_VARSTORE_ID;
  Goto.Question.QuestionId    = QuestionId;
  Goto.Question.Flags         = QuestionFlags;
  Goto.FormId                 = FormId;

  LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
  CopyMem (LocalBuffer, &Goto, sizeof (EFI_IFR_REF));
  Data->Offset += sizeof (EFI_IFR_REF);

  return EFI_SUCCESS;
}

EFI_STATUS
EFIAPI
CreateOneOfOptionOpCode (
  IN     UINTN                OptionCount,
  IN     IFR_OPTION           *OptionsList,
  IN     UINT8                Type,
  IN OUT EFI_HII_UPDATE_DATA  *Data
  )
{
  UINTN                       Index;
  UINT8                       *LocalBuffer;
  EFI_IFR_ONE_OF_OPTION       OneOfOption;

  ASSERT (Data != NULL && Data->Data != NULL);

  if ((OptionCount != 0) && (OptionsList == NULL)) {
    return EFI_INVALID_PARAMETER;
  }

  if (Data->Offset + OptionCount * sizeof (EFI_IFR_ONE_OF_OPTION) > Data->BufferSize) {
    return EFI_BUFFER_TOO_SMALL;
  }

  for (Index = 0; Index < OptionCount; Index++) {
    OneOfOption.Header.OpCode = EFI_IFR_ONE_OF_OPTION_OP;
    OneOfOption.Header.Length = sizeof (EFI_IFR_ONE_OF_OPTION);
    OneOfOption.Header.Scope  = 0;

    OneOfOption.Option        = OptionsList[Index].StringToken;
    OneOfOption.Value         = OptionsList[Index].Value;
    OneOfOption.Flags         = (UINT8) (OptionsList[Index].Flags & (EFI_IFR_OPTION_DEFAULT | EFI_IFR_OPTION_DEFAULT_MFG));
    OneOfOption.Type          = Type;

    LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
    CopyMem (LocalBuffer, &OneOfOption, sizeof (EFI_IFR_ONE_OF_OPTION));
    Data->Offset += sizeof (EFI_IFR_ONE_OF_OPTION);
  }

  return EFI_SUCCESS;
}

EFI_STATUS
EFIAPI
CreateOneOfOpCode (
  IN     EFI_QUESTION_ID      QuestionId,
  IN     EFI_VARSTORE_ID      VarStoreId,
  IN     UINT16               VarOffset,
  IN     EFI_STRING_ID        Prompt,
  IN     EFI_STRING_ID        Help,
  IN     UINT8                QuestionFlags,
  IN     UINT8                OneOfFlags,
  IN     IFR_OPTION           *OptionsList,
  IN     UINTN                OptionCount,
  IN OUT EFI_HII_UPDATE_DATA  *Data
  )
{
  UINTN                       Length;
  EFI_IFR_ONE_OF              OneOf;
  UINT8                       *LocalBuffer;

  ASSERT (Data != NULL && Data->Data != NULL);

  if (!IsValidNumricFlags (OneOfFlags) ||
      !IsValidQuestionFlags (QuestionFlags) ||
      ((OptionCount != 0) && (OptionsList == NULL))) {
    return EFI_INVALID_PARAMETER;
  }

  Length = sizeof (EFI_IFR_ONE_OF) + OptionCount * sizeof (EFI_IFR_ONE_OF_OPTION) + sizeof (EFI_IFR_END);
  if (Data->Offset + Length > Data->BufferSize) {
    return EFI_BUFFER_TOO_SMALL;
  }

  OneOf.Header.OpCode                   = EFI_IFR_ONE_OF_OP;
  OneOf.Header.Length                   = sizeof (EFI_IFR_ONE_OF);
  OneOf.Header.Scope                    = 1;
  OneOf.Question.Header.Prompt          = Prompt;
  OneOf.Question.Header.Help            = Help;
  OneOf.Question.QuestionId             = QuestionId;
  OneOf.Question.VarStoreId             = VarStoreId;
  OneOf.Question.VarStoreInfo.VarOffset = VarOffset;
  OneOf.Question.Flags                  = QuestionFlags;
  OneOf.Flags                           = OneOfFlags;
  ZeroMem ((VOID *) &OneOf.data, sizeof (MINMAXSTEP_DATA));

  LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
  CopyMem (LocalBuffer, &OneOf, sizeof (EFI_IFR_ONE_OF));
  Data->Offset += sizeof (EFI_IFR_ONE_OF);

  CreateOneOfOptionOpCode (OptionCount, OptionsList, (UINT8) (OneOfFlags & EFI_IFR_NUMERIC_SIZE), Data);

  CreateEndOpCode (Data);

  return EFI_SUCCESS;
}

EFI_STATUS
EFIAPI
CreateOrderedListOpCode (
  IN      EFI_QUESTION_ID     QuestionId,
  IN      EFI_VARSTORE_ID     VarStoreId,
  IN      UINT16              VarOffset,
  IN      EFI_STRING_ID       Prompt,
  IN      EFI_STRING_ID       Help,
  IN      UINT8               QuestionFlags,
  IN      UINT8               OrderedListFlags,
  IN      UINT8               DataType,
  IN      UINT8               MaxContainers,
  IN      IFR_OPTION          *OptionsList,
  IN     UINTN                OptionCount,
  IN OUT EFI_HII_UPDATE_DATA  *Data
  )
{
  UINTN                       Length;
  EFI_IFR_ORDERED_LIST        OrderedList;
  UINT8                       *LocalBuffer;

  ASSERT (Data != NULL && Data->Data != NULL);

  if (!IsValidQuestionFlags (QuestionFlags) ||
      ((OptionCount != 0) && (OptionsList == NULL))) {
    return EFI_INVALID_PARAMETER;
  }

  if ((OrderedListFlags != 0) &&
      (OrderedListFlags != EFI_IFR_UNIQUE_SET) &&
      (OrderedListFlags != EFI_IFR_NO_EMPTY_SET)) {
    return EFI_INVALID_PARAMETER;
  }

  Length = sizeof (EFI_IFR_ORDERED_LIST) + OptionCount * sizeof (EFI_IFR_ONE_OF_OPTION) + sizeof (EFI_IFR_END);
  if (Data->Offset + Length > Data->BufferSize) {
    return EFI_BUFFER_TOO_SMALL;
  }

  OrderedList.Header.OpCode                   = EFI_IFR_ORDERED_LIST_OP;
  OrderedList.Header.Length                   = sizeof (EFI_IFR_ORDERED_LIST);
  OrderedList.Header.Scope                    = 1;
  OrderedList.Question.Header.Prompt          = Prompt;
  OrderedList.Question.Header.Help            = Help;
  OrderedList.Question.QuestionId             = QuestionId;
  OrderedList.Question.VarStoreId             = VarStoreId;
  OrderedList.Question.VarStoreInfo.VarOffset = VarOffset;
  OrderedList.Question.Flags                  = QuestionFlags;
  OrderedList.MaxContainers                   = MaxContainers;
  OrderedList.Flags                           = OrderedListFlags;

  LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
  CopyMem (LocalBuffer, &OrderedList, sizeof (EFI_IFR_ORDERED_LIST));
  Data->Offset += sizeof (EFI_IFR_ORDERED_LIST);

  CreateOneOfOptionOpCode (OptionCount, OptionsList, DataType, Data);

  CreateEndOpCode (Data);

  return EFI_SUCCESS;
}

EFI_STATUS
EFIAPI
CreateCheckBoxOpCode (
  IN      EFI_QUESTION_ID     QuestionId,
  IN      EFI_VARSTORE_ID     VarStoreId,
  IN      UINT16              VarOffset,
  IN      EFI_STRING_ID       Prompt,
  IN      EFI_STRING_ID       Help,
  IN      UINT8               QuestionFlags,
  IN      UINT8               CheckBoxFlags,
  IN OUT EFI_HII_UPDATE_DATA  *Data
  )
{
  EFI_IFR_CHECKBOX            CheckBox;
  UINT8                       *LocalBuffer;

  ASSERT (Data != NULL && Data->Data != NULL);

  if (!IsValidQuestionFlags (QuestionFlags) || !IsValidCheckboxFlags (CheckBoxFlags)) {
    return EFI_INVALID_PARAMETER;
  }

  if (Data->Offset + sizeof (EFI_IFR_CHECKBOX) > Data->BufferSize) {
    return EFI_BUFFER_TOO_SMALL;
  }

  CheckBox.Header.OpCode                   = EFI_IFR_CHECKBOX_OP;
  CheckBox.Header.Length                   = sizeof (EFI_IFR_CHECKBOX);
  CheckBox.Header.Scope                    = 0;
  CheckBox.Question.QuestionId             = QuestionId;
  CheckBox.Question.VarStoreId             = VarStoreId;
  CheckBox.Question.VarStoreInfo.VarOffset = VarOffset;
  CheckBox.Question.Header.Prompt          = Prompt;
  CheckBox.Question.Header.Help            = Help;
  CheckBox.Question.Flags                  = QuestionFlags;
  CheckBox.Flags                           = CheckBoxFlags;

  LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
  CopyMem (LocalBuffer, &CheckBox, sizeof (EFI_IFR_CHECKBOX));
  Data->Offset += sizeof (EFI_IFR_CHECKBOX);

  return EFI_SUCCESS;
}

EFI_STATUS
EFIAPI
CreateNumericOpCode (
  IN     EFI_QUESTION_ID     QuestionId,
  IN     EFI_VARSTORE_ID     VarStoreId,
  IN     UINT16              VarOffset,
  IN     EFI_STRING_ID       Prompt,
  IN     EFI_STRING_ID       Help,
  IN     UINT8               QuestionFlags,
  IN     UINT8               NumericFlags,
  IN     UINT64              Minimum,
  IN     UINT64              Maximum,
  IN     UINT64              Step,
  IN     UINT64              Default,
  IN OUT EFI_HII_UPDATE_DATA *Data
  )
{
  EFI_STATUS                  Status;
  EFI_IFR_NUMERIC             Numeric;
  MINMAXSTEP_DATA             MinMaxStep;
  EFI_IFR_TYPE_VALUE          DefaultValue;
  UINT8                       *LocalBuffer;

  ASSERT (Data != NULL && Data->Data != NULL);

  if (!IsValidQuestionFlags (QuestionFlags) || !IsValidNumricFlags (NumericFlags)) {
    return EFI_INVALID_PARAMETER;
  }

  if (Data->Offset + sizeof (EFI_IFR_CHECKBOX) > Data->BufferSize) {
    return EFI_BUFFER_TOO_SMALL;
  }

  Numeric.Header.OpCode                   = EFI_IFR_NUMERIC_OP;
  Numeric.Header.Length                   = sizeof (EFI_IFR_NUMERIC);
  Numeric.Header.Scope                    = 1;
  Numeric.Question.QuestionId             = QuestionId;
  Numeric.Question.VarStoreId             = VarStoreId;
  Numeric.Question.VarStoreInfo.VarOffset = VarOffset;
  Numeric.Question.Header.Prompt          = Prompt;
  Numeric.Question.Header.Help            = Help;
  Numeric.Question.Flags                  = QuestionFlags;
  Numeric.Flags                           = NumericFlags;

  switch (NumericFlags & EFI_IFR_NUMERIC_SIZE) {
  case EFI_IFR_NUMERIC_SIZE_1:
    MinMaxStep.u8.MinValue = (UINT8) Minimum;
    MinMaxStep.u8.MaxValue = (UINT8) Maximum;
    MinMaxStep.u8.Step     = (UINT8) Step;
    break;

  case EFI_IFR_NUMERIC_SIZE_2:
    MinMaxStep.u16.MinValue = (UINT16) Minimum;
    MinMaxStep.u16.MaxValue = (UINT16) Maximum;
    MinMaxStep.u16.Step     = (UINT16) Step;
    break;

  case EFI_IFR_NUMERIC_SIZE_4:
    MinMaxStep.u32.MinValue = (UINT32) Minimum;
    MinMaxStep.u32.MaxValue = (UINT32) Maximum;
    MinMaxStep.u32.Step     = (UINT32) Step;
    break;

  case EFI_IFR_NUMERIC_SIZE_8:
    MinMaxStep.u64.MinValue = Minimum;
    MinMaxStep.u64.MaxValue = Maximum;
    MinMaxStep.u64.Step     = Step;
    break;
  }

  CopyMem (&Numeric.data, &MinMaxStep, sizeof (MINMAXSTEP_DATA));

  LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
  CopyMem (LocalBuffer, &Numeric, sizeof (EFI_IFR_NUMERIC));
  Data->Offset += sizeof (EFI_IFR_NUMERIC);

  DefaultValue.u64 = Default;
  Status = CreateDefaultOpCode (&DefaultValue, (UINT8) (NumericFlags & EFI_IFR_NUMERIC_SIZE), Data);
  if (EFI_ERROR(Status)) {
    return Status;
  }

  CreateEndOpCode (Data);

  return EFI_SUCCESS;
}

EFI_STATUS
EFIAPI
CreateStringOpCode (
  IN      EFI_QUESTION_ID     QuestionId,
  IN      EFI_VARSTORE_ID     VarStoreId,
  IN      UINT16              VarOffset,
  IN      EFI_STRING_ID       Prompt,
  IN      EFI_STRING_ID       Help,
  IN      UINT8               QuestionFlags,
  IN      UINT8               StringFlags,
  IN      UINT8               MinSize,
  IN      UINT8               MaxSize,
  IN OUT EFI_HII_UPDATE_DATA  *Data
  )
{
  EFI_IFR_STRING              String;
  UINT8                       *LocalBuffer;

  ASSERT (Data != NULL && Data->Data != NULL);

  if (!IsValidQuestionFlags (QuestionFlags) || (StringFlags & (~EFI_IFR_STRING_MULTI_LINE))) {
    return EFI_INVALID_PARAMETER;
  }

  if (Data->Offset + sizeof (EFI_IFR_STRING) > Data->BufferSize) {
    return EFI_BUFFER_TOO_SMALL;
  }

  String.Header.OpCode                   = EFI_IFR_STRING_OP;
  String.Header.Length                   = sizeof (EFI_IFR_STRING);
  String.Header.Scope                    = 0;
  String.Question.Header.Prompt          = Prompt;
  String.Question.Header.Help            = Help;
  String.Question.QuestionId             = QuestionId;
  String.Question.VarStoreId             = VarStoreId;
  String.Question.VarStoreInfo.VarOffset = VarOffset;
  String.Question.Flags                  = QuestionFlags;
  String.MinSize                         = MinSize;
  String.MaxSize                         = MaxSize;
  String.Flags                           = StringFlags;

  LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
  CopyMem (LocalBuffer, &String, sizeof (EFI_IFR_STRING));
  Data->Offset += sizeof (EFI_IFR_STRING);

  return EFI_SUCCESS;
}
Commit	Line	Data
e52c5a9f	1	/** @file
	2
	3	Copyright (c) 2007, Intel Corporation
	4	All rights reserved. This program and the accompanying materials
	5	are licensed and made available under the terms and conditions of the BSD License
	6	which accompanies this distribution. The full text of the license may be found at
	7	http://opensource.org/licenses/bsd-license.php
	8
	9	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
	10	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
	11
	12	Module Name:
	13
	14	UefiIfrOpCodeCreation.c
	15
	16	Abstract:
	17
	18	Library Routines to create IFR independent of string data - assume tokens already exist
	19	Primarily to be used for exporting op-codes at a label in pre-defined forms.
	20
	21	Revision History:
	22
	23
	24	**/
	25
	26	#include "UefiIfrLibraryInternal.h"
	27
	28	STATIC
	29	BOOLEAN
	30	IsValidQuestionFlags (
	31	IN UINT8 Flags
	32	)
	33	{
	34	return (BOOLEAN) ((Flags & (~QUESTION_FLAGS)) ? FALSE : TRUE);
	35	}
	36
	37	STATIC
	38	BOOLEAN
	39	IsValidValueType (
	40	IN UINT8 Type
	41	)
	42	{
	43	return (BOOLEAN) ((Type <= EFI_IFR_TYPE_OTHER) ? TRUE : FALSE);
	44	}
	45
	46	STATIC
	47	BOOLEAN
	48	IsValidNumricFlags (
	49	IN UINT8 Flags
	50	)
	51	{
	52	if (Flags & ~(EFI_IFR_NUMERIC_SIZE \| EFI_IFR_DISPLAY)) {
	53	return FALSE;
	54	}
	55
	56	if ((Flags & EFI_IFR_DISPLAY) > EFI_IFR_DISPLAY_UINT_HEX) {
	57	return FALSE;
	58	}
	59
	60	return TRUE;
	61	}
	62
	63	STATIC
	64	BOOLEAN
65	IsValidCheckboxFlags (
66	IN UINT8 Flags
67	)
68	{
69	return (BOOLEAN) ((Flags <= EFI_IFR_CHECKBOX_DEFAULT_MFG) ? TRUE : FALSE);
70	}
71
72	EFI_STATUS
73	EFIAPI
74	CreateEndOpCode (
75	IN OUT EFI_HII_UPDATE_DATA *Data
76	)
77	{
78	EFI_IFR_END End;
79	UINT8 *LocalBuffer;
80
81	ASSERT (Data != NULL && Data->Data != NULL);
82
83	if (Data->Offset + sizeof (EFI_IFR_END) > Data->BufferSize) {
84	return EFI_BUFFER_TOO_SMALL;
85	}
86
87	End.Header.Length = sizeof (EFI_IFR_END);
88	End.Header.OpCode = EFI_IFR_END_OP;
89	End.Header.Scope = 0;
90
91	LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
92	CopyMem (LocalBuffer, &End, sizeof (EFI_IFR_END));
93	Data->Offset += sizeof (EFI_IFR_END);
94
95	return EFI_SUCCESS;
96	}
97
98	EFI_STATUS
99	EFIAPI
100	CreateDefaultOpCode (
101	IN EFI_IFR_TYPE_VALUE *Value,
102	IN UINT8 Type,
103	IN OUT EFI_HII_UPDATE_DATA *Data
104	)
105	{
106	EFI_IFR_DEFAULT Default;
107	UINT8 *LocalBuffer;
108
109	ASSERT (Data != NULL && Data->Data != NULL);
110
111	if ((Value == NULL) \|\| !IsValidValueType (Type)) {
112	return EFI_INVALID_PARAMETER;
113	}
114
115	if (Data->Offset + sizeof (EFI_IFR_DEFAULT) > Data->BufferSize) {
116	return EFI_BUFFER_TOO_SMALL;
117	}
118
119	Default.Header.OpCode = EFI_IFR_DEFAULT_OP;
120	Default.Header.Length = sizeof (EFI_IFR_DEFAULT);
121	Default.Header.Scope = 0;
122	Default.Type = Type;
123	Default.DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD;
124	CopyMem (&Default.Value, Value, sizeof(EFI_IFR_TYPE_VALUE));
125
126	LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
127	CopyMem (LocalBuffer, &Default, sizeof (EFI_IFR_DEFAULT));
128	Data->Offset += sizeof (EFI_IFR_DEFAULT);
129
130	return EFI_SUCCESS;
131	}
132
133	EFI_STATUS
134	EFIAPI
135	CreateActionOpCode (
136	IN EFI_QUESTION_ID QuestionId,
137	IN EFI_STRING_ID Prompt,
138	IN EFI_STRING_ID Help,
139	IN UINT8 QuestionFlags,
140	IN EFI_STRING_ID QuestionConfig,
141	IN OUT EFI_HII_UPDATE_DATA *Data
142	)
143	{
144	EFI_IFR_ACTION Action;
145	UINT8 *LocalBuffer;
146
147	ASSERT (Data != NULL && Data->Data != NULL);
148
149	if (!IsValidQuestionFlags (QuestionFlags)) {
150	return EFI_INVALID_PARAMETER;
151	}
152
153	if (Data->Offset + sizeof (EFI_IFR_ACTION) > Data->BufferSize) {
154	return EFI_BUFFER_TOO_SMALL;
155	}
156
157	Action.Header.OpCode = EFI_IFR_ACTION_OP;
158	Action.Header.Length = sizeof (EFI_IFR_ACTION);
159	Action.Header.Scope = 0;
160	Action.Question.QuestionId = QuestionId;
161	Action.Question.Header.Prompt = Prompt;
162	Action.Question.Header.Help = Help;
163	Action.Question.VarStoreId = INVALID_VARSTORE_ID;
164	Action.Question.Flags = QuestionFlags;
165	Action.QuestionConfig = QuestionConfig;
166
167	LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
168	CopyMem (LocalBuffer, &Action, sizeof (EFI_IFR_ACTION));
169	Data->Offset += sizeof (EFI_IFR_ACTION);
170
171	return EFI_SUCCESS;
172	}
173
174	EFI_STATUS
175	EFIAPI
176	CreateSubTitleOpCode (
177	IN EFI_STRING_ID Prompt,
178	IN EFI_STRING_ID Help,
179	IN UINT8 Flags,
180	IN UINT8 Scope,
181	IN OUT EFI_HII_UPDATE_DATA *Data
182	)
183	{
184	EFI_IFR_SUBTITLE Subtitle;
185	UINT8 *LocalBuffer;
186
187	ASSERT (Data != NULL && Data->Data != NULL);
188
189	if (Data->Offset + sizeof (EFI_IFR_SUBTITLE) > Data->BufferSize) {
190	return EFI_BUFFER_TOO_SMALL;
191	}
192
193	Subtitle.Header.OpCode = EFI_IFR_SUBTITLE_OP;
194	Subtitle.Header.Length = sizeof (EFI_IFR_SUBTITLE);
195	Subtitle.Header.Scope = Scope;
196	Subtitle.Statement.Prompt = Prompt;
197	Subtitle.Statement.Help = Help;
198	Subtitle.Flags = Flags;
199
200	LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
201	CopyMem (LocalBuffer, &Subtitle, sizeof (EFI_IFR_SUBTITLE));
202	Data->Offset += sizeof (EFI_IFR_SUBTITLE);
203
204	return EFI_SUCCESS;
205	}
206
207
208	EFI_STATUS
209	EFIAPI
210	CreateTextOpCode (
211	IN EFI_STRING_ID Prompt,
212	IN EFI_STRING_ID Help,
213	IN EFI_STRING_ID TextTwo,
214	IN OUT EFI_HII_UPDATE_DATA *Data
215	)
216	{
217	EFI_IFR_TEXT Text;
218	UINT8 *LocalBuffer;
219
220	ASSERT (Data != NULL && Data->Data != NULL);
221
222	if (Data->Offset + sizeof (EFI_IFR_TEXT) > Data->BufferSize) {
223	return EFI_BUFFER_TOO_SMALL;
224	}
225
226	Text.Header.OpCode = EFI_IFR_TEXT_OP;
227	Text.Header.Length = sizeof (EFI_IFR_TEXT);
228	Text.Header.Scope = 0;
229	Text.Statement.Prompt = Prompt;
230	Text.Statement.Help = Help;
231	Text.TextTwo = TextTwo;
232
233	LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
234	CopyMem (LocalBuffer, &Text, sizeof (EFI_IFR_TEXT));
235	Data->Offset += sizeof (EFI_IFR_TEXT);
236
237	return EFI_SUCCESS;
238	}
239
240	EFI_STATUS
241	EFIAPI
242	CreateGotoOpCode (
243	IN EFI_FORM_ID FormId,
244	IN EFI_STRING_ID Prompt,
245	IN EFI_STRING_ID Help,
246	IN UINT8 QuestionFlags,
247	IN EFI_QUESTION_ID QuestionId,
248	IN OUT EFI_HII_UPDATE_DATA *Data
249	)
250	{
251	EFI_IFR_REF Goto;
252	UINT8 *LocalBuffer;
253
254	ASSERT (Data != NULL && Data->Data != NULL);
255
256	if (!IsValidQuestionFlags (QuestionFlags)) {
257	return EFI_INVALID_PARAMETER;
258	}
259
260	if (Data->Offset + sizeof (EFI_IFR_REF) > Data->BufferSize) {
261	return EFI_BUFFER_TOO_SMALL;
262	}
263
264	Goto.Header.OpCode = EFI_IFR_REF_OP;
265	Goto.Header.Length = sizeof (EFI_IFR_REF);
266	Goto.Header.Scope = 0;
267	Goto.Question.Header.Prompt = Prompt;
268	Goto.Question.Header.Help = Help;
269	Goto.Question.VarStoreId = INVALID_VARSTORE_ID;
270	Goto.Question.QuestionId = QuestionId;
271	Goto.Question.Flags = QuestionFlags;
272	Goto.FormId = FormId;
273
274	LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
275	CopyMem (LocalBuffer, &Goto, sizeof (EFI_IFR_REF));
276	Data->Offset += sizeof (EFI_IFR_REF);
277
278	return EFI_SUCCESS;
279	}
280
281	EFI_STATUS
282	EFIAPI
283	CreateOneOfOptionOpCode (
284	IN UINTN OptionCount,
285	IN IFR_OPTION *OptionsList,
286	IN UINT8 Type,
287	IN OUT EFI_HII_UPDATE_DATA *Data
288	)
289	{
290	UINTN Index;
291	UINT8 *LocalBuffer;
292	EFI_IFR_ONE_OF_OPTION OneOfOption;
293
294	ASSERT (Data != NULL && Data->Data != NULL);
295
296	if ((OptionCount != 0) && (OptionsList == NULL)) {
297	return EFI_INVALID_PARAMETER;
298	}
299
300	if (Data->Offset + OptionCount * sizeof (EFI_IFR_ONE_OF_OPTION) > Data->BufferSize) {
301	return EFI_BUFFER_TOO_SMALL;
302	}
303
304	for (Index = 0; Index < OptionCount; Index++) {
305	OneOfOption.Header.OpCode = EFI_IFR_ONE_OF_OPTION_OP;
306	OneOfOption.Header.Length = sizeof (EFI_IFR_ONE_OF_OPTION);
307	OneOfOption.Header.Scope = 0;
308
309	OneOfOption.Option = OptionsList[Index].StringToken;
310	OneOfOption.Value = OptionsList[Index].Value;
311	OneOfOption.Flags = (UINT8) (OptionsList[Index].Flags & (EFI_IFR_OPTION_DEFAULT \| EFI_IFR_OPTION_DEFAULT_MFG));
312	OneOfOption.Type = Type;
313
314	LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
315	CopyMem (LocalBuffer, &OneOfOption, sizeof (EFI_IFR_ONE_OF_OPTION));
316	Data->Offset += sizeof (EFI_IFR_ONE_OF_OPTION);
317	}
318
319	return EFI_SUCCESS;
320	}
321
322	EFI_STATUS
323	EFIAPI
324	CreateOneOfOpCode (
325	IN EFI_QUESTION_ID QuestionId,
326	IN EFI_VARSTORE_ID VarStoreId,
327	IN UINT16 VarOffset,
328	IN EFI_STRING_ID Prompt,
329	IN EFI_STRING_ID Help,
330	IN UINT8 QuestionFlags,
331	IN UINT8 OneOfFlags,
332	IN IFR_OPTION *OptionsList,
333	IN UINTN OptionCount,
334	IN OUT EFI_HII_UPDATE_DATA *Data
335	)
336	{
337	UINTN Length;
338	EFI_IFR_ONE_OF OneOf;
339	UINT8 *LocalBuffer;
340
341	ASSERT (Data != NULL && Data->Data != NULL);
342
343	if (!IsValidNumricFlags (OneOfFlags) \|\|
344	!IsValidQuestionFlags (QuestionFlags) \|\|
345	((OptionCount != 0) && (OptionsList == NULL))) {
346	return EFI_INVALID_PARAMETER;
347	}
348
349	Length = sizeof (EFI_IFR_ONE_OF) + OptionCount * sizeof (EFI_IFR_ONE_OF_OPTION) + sizeof (EFI_IFR_END);
350	if (Data->Offset + Length > Data->BufferSize) {
351	return EFI_BUFFER_TOO_SMALL;
352	}
353
354	OneOf.Header.OpCode = EFI_IFR_ONE_OF_OP;
355	OneOf.Header.Length = sizeof (EFI_IFR_ONE_OF);
356	OneOf.Header.Scope = 1;
357	OneOf.Question.Header.Prompt = Prompt;
358	OneOf.Question.Header.Help = Help;
359	OneOf.Question.QuestionId = QuestionId;
360	OneOf.Question.VarStoreId = VarStoreId;
361	OneOf.Question.VarStoreInfo.VarOffset = VarOffset;
362	OneOf.Question.Flags = QuestionFlags;
363	OneOf.Flags = OneOfFlags;
364	ZeroMem ((VOID *) &OneOf.data, sizeof (MINMAXSTEP_DATA));
365
366	LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
367	CopyMem (LocalBuffer, &OneOf, sizeof (EFI_IFR_ONE_OF));
368	Data->Offset += sizeof (EFI_IFR_ONE_OF);
369
370	CreateOneOfOptionOpCode (OptionCount, OptionsList, (UINT8) (OneOfFlags & EFI_IFR_NUMERIC_SIZE), Data);
371
372	CreateEndOpCode (Data);
373
374	return EFI_SUCCESS;
375	}
376
377	EFI_STATUS
378	EFIAPI
379	CreateOrderedListOpCode (
380	IN EFI_QUESTION_ID QuestionId,
381	IN EFI_VARSTORE_ID VarStoreId,
382	IN UINT16 VarOffset,
383	IN EFI_STRING_ID Prompt,
384	IN EFI_STRING_ID Help,
385	IN UINT8 QuestionFlags,
386	IN UINT8 OrderedListFlags,
387	IN UINT8 DataType,
388	IN UINT8 MaxContainers,
389	IN IFR_OPTION *OptionsList,
390	IN UINTN OptionCount,
391	IN OUT EFI_HII_UPDATE_DATA *Data
392	)
393	{
394	UINTN Length;
395	EFI_IFR_ORDERED_LIST OrderedList;
396	UINT8 *LocalBuffer;
397
398	ASSERT (Data != NULL && Data->Data != NULL);
399
400	if (!IsValidQuestionFlags (QuestionFlags) \|\|
401	((OptionCount != 0) && (OptionsList == NULL))) {
402	return EFI_INVALID_PARAMETER;
403	}
404
405	if ((OrderedListFlags != 0) &&
406	(OrderedListFlags != EFI_IFR_UNIQUE_SET) &&
407	(OrderedListFlags != EFI_IFR_NO_EMPTY_SET)) {
408	return EFI_INVALID_PARAMETER;
409	}
410
411	Length = sizeof (EFI_IFR_ORDERED_LIST) + OptionCount * sizeof (EFI_IFR_ONE_OF_OPTION) + sizeof (EFI_IFR_END);
412	if (Data->Offset + Length > Data->BufferSize) {
413	return EFI_BUFFER_TOO_SMALL;
414	}
415
416	OrderedList.Header.OpCode = EFI_IFR_ORDERED_LIST_OP;
417	OrderedList.Header.Length = sizeof (EFI_IFR_ORDERED_LIST);
418	OrderedList.Header.Scope = 1;
419	OrderedList.Question.Header.Prompt = Prompt;
420	OrderedList.Question.Header.Help = Help;
421	OrderedList.Question.QuestionId = QuestionId;
422	OrderedList.Question.VarStoreId = VarStoreId;
423	OrderedList.Question.VarStoreInfo.VarOffset = VarOffset;
424	OrderedList.Question.Flags = QuestionFlags;
425	OrderedList.MaxContainers = MaxContainers;
426	OrderedList.Flags = OrderedListFlags;
427
428	LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
429	CopyMem (LocalBuffer, &OrderedList, sizeof (EFI_IFR_ORDERED_LIST));
430	Data->Offset += sizeof (EFI_IFR_ORDERED_LIST);
431
432	CreateOneOfOptionOpCode (OptionCount, OptionsList, DataType, Data);
433
434	CreateEndOpCode (Data);
435
436	return EFI_SUCCESS;
437	}
438
439	EFI_STATUS
440	EFIAPI
441	CreateCheckBoxOpCode (
442	IN EFI_QUESTION_ID QuestionId,
443	IN EFI_VARSTORE_ID VarStoreId,
444	IN UINT16 VarOffset,
445	IN EFI_STRING_ID Prompt,
446	IN EFI_STRING_ID Help,
447	IN UINT8 QuestionFlags,
448	IN UINT8 CheckBoxFlags,
449	IN OUT EFI_HII_UPDATE_DATA *Data
450	)
451	{
452	EFI_IFR_CHECKBOX CheckBox;
453	UINT8 *LocalBuffer;
454
455	ASSERT (Data != NULL && Data->Data != NULL);
456
457	if (!IsValidQuestionFlags (QuestionFlags) \|\| !IsValidCheckboxFlags (CheckBoxFlags)) {
458	return EFI_INVALID_PARAMETER;
459	}
460
461	if (Data->Offset + sizeof (EFI_IFR_CHECKBOX) > Data->BufferSize) {
462	return EFI_BUFFER_TOO_SMALL;
463	}
464
465	CheckBox.Header.OpCode = EFI_IFR_CHECKBOX_OP;
466	CheckBox.Header.Length = sizeof (EFI_IFR_CHECKBOX);
467	CheckBox.Header.Scope = 0;
468	CheckBox.Question.QuestionId = QuestionId;
469	CheckBox.Question.VarStoreId = VarStoreId;
470	CheckBox.Question.VarStoreInfo.VarOffset = VarOffset;
471	CheckBox.Question.Header.Prompt = Prompt;
472	CheckBox.Question.Header.Help = Help;
473	CheckBox.Question.Flags = QuestionFlags;
474	CheckBox.Flags = CheckBoxFlags;
475
476	LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
477	CopyMem (LocalBuffer, &CheckBox, sizeof (EFI_IFR_CHECKBOX));
478	Data->Offset += sizeof (EFI_IFR_CHECKBOX);
479
480	return EFI_SUCCESS;
481	}
482
483	EFI_STATUS
484	EFIAPI
485	CreateNumericOpCode (
486	IN EFI_QUESTION_ID QuestionId,
487	IN EFI_VARSTORE_ID VarStoreId,
488	IN UINT16 VarOffset,
489	IN EFI_STRING_ID Prompt,
490	IN EFI_STRING_ID Help,
491	IN UINT8 QuestionFlags,
492	IN UINT8 NumericFlags,
493	IN UINT64 Minimum,
494	IN UINT64 Maximum,
495	IN UINT64 Step,
496	IN UINT64 Default,
497	IN OUT EFI_HII_UPDATE_DATA *Data
498	)
499	{
500	EFI_STATUS Status;
501	EFI_IFR_NUMERIC Numeric;
502	MINMAXSTEP_DATA MinMaxStep;
503	EFI_IFR_TYPE_VALUE DefaultValue;
504	UINT8 *LocalBuffer;
505
506	ASSERT (Data != NULL && Data->Data != NULL);
507
508	if (!IsValidQuestionFlags (QuestionFlags) \|\| !IsValidNumricFlags (NumericFlags)) {
509	return EFI_INVALID_PARAMETER;
510	}
511
512	if (Data->Offset + sizeof (EFI_IFR_CHECKBOX) > Data->BufferSize) {
513	return EFI_BUFFER_TOO_SMALL;
514	}
515
516	Numeric.Header.OpCode = EFI_IFR_NUMERIC_OP;
517	Numeric.Header.Length = sizeof (EFI_IFR_NUMERIC);
518	Numeric.Header.Scope = 1;
519	Numeric.Question.QuestionId = QuestionId;
520	Numeric.Question.VarStoreId = VarStoreId;
521	Numeric.Question.VarStoreInfo.VarOffset = VarOffset;
522	Numeric.Question.Header.Prompt = Prompt;
523	Numeric.Question.Header.Help = Help;
524	Numeric.Question.Flags = QuestionFlags;
525	Numeric.Flags = NumericFlags;
526
527	switch (NumericFlags & EFI_IFR_NUMERIC_SIZE) {
528	case EFI_IFR_NUMERIC_SIZE_1:
529	MinMaxStep.u8.MinValue = (UINT8) Minimum;
530	MinMaxStep.u8.MaxValue = (UINT8) Maximum;
531	MinMaxStep.u8.Step = (UINT8) Step;
532	break;
533
534	case EFI_IFR_NUMERIC_SIZE_2:
535	MinMaxStep.u16.MinValue = (UINT16) Minimum;
536	MinMaxStep.u16.MaxValue = (UINT16) Maximum;
537	MinMaxStep.u16.Step = (UINT16) Step;
538	break;
539
540	case EFI_IFR_NUMERIC_SIZE_4:
541	MinMaxStep.u32.MinValue = (UINT32) Minimum;
542	MinMaxStep.u32.MaxValue = (UINT32) Maximum;
543	MinMaxStep.u32.Step = (UINT32) Step;
544	break;
545
546	case EFI_IFR_NUMERIC_SIZE_8:
547	MinMaxStep.u64.MinValue = Minimum;
548	MinMaxStep.u64.MaxValue = Maximum;
549	MinMaxStep.u64.Step = Step;
550	break;
551	}
552
553	CopyMem (&Numeric.data, &MinMaxStep, sizeof (MINMAXSTEP_DATA));
554
555	LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
556	CopyMem (LocalBuffer, &Numeric, sizeof (EFI_IFR_NUMERIC));
557	Data->Offset += sizeof (EFI_IFR_NUMERIC);
558
559	DefaultValue.u64 = Default;
560	Status = CreateDefaultOpCode (&DefaultValue, (UINT8) (NumericFlags & EFI_IFR_NUMERIC_SIZE), Data);
561	if (EFI_ERROR(Status)) {
562	return Status;
563	}
564
565	CreateEndOpCode (Data);
566
567	return EFI_SUCCESS;
568	}
569
570	EFI_STATUS
571	EFIAPI
572	CreateStringOpCode (
573	IN EFI_QUESTION_ID QuestionId,
574	IN EFI_VARSTORE_ID VarStoreId,
575	IN UINT16 VarOffset,
576	IN EFI_STRING_ID Prompt,
577	IN EFI_STRING_ID Help,
578	IN UINT8 QuestionFlags,
579	IN UINT8 StringFlags,
580	IN UINT8 MinSize,
581	IN UINT8 MaxSize,
582	IN OUT EFI_HII_UPDATE_DATA *Data
583	)
584	{
585	EFI_IFR_STRING String;
586	UINT8 *LocalBuffer;
587
588	ASSERT (Data != NULL && Data->Data != NULL);
589
590	if (!IsValidQuestionFlags (QuestionFlags) \|\| (StringFlags & (~EFI_IFR_STRING_MULTI_LINE))) {
591	return EFI_INVALID_PARAMETER;
592	}
593
594	if (Data->Offset + sizeof (EFI_IFR_STRING) > Data->BufferSize) {
595	return EFI_BUFFER_TOO_SMALL;
596	}
597
598	String.Header.OpCode = EFI_IFR_STRING_OP;
599	String.Header.Length = sizeof (EFI_IFR_STRING);
600	String.Header.Scope = 0;
601	String.Question.Header.Prompt = Prompt;
602	String.Question.Header.Help = Help;
603	String.Question.QuestionId = QuestionId;
604	String.Question.VarStoreId = VarStoreId;
605	String.Question.VarStoreInfo.VarOffset = VarOffset;
606	String.Question.Flags = QuestionFlags;
607	String.MinSize = MinSize;
608	String.MaxSize = MaxSize;
609	String.Flags = StringFlags;
610
611	LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
612	CopyMem (LocalBuffer, &String, sizeof (EFI_IFR_STRING));
613	Data->Offset += sizeof (EFI_IFR_STRING);
614
615	return EFI_SUCCESS;
616	}
617
618