MdePkg/Library/IfrSupportLib/UefiIfrOpCodeCreation.c

   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