MdeModulePkg/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 EFI_GUID mIfrVendorGuid = EFI_IFR_TIANO_GUID;
  29
  30 STATIC
  31 BOOLEAN
  32 IsValidQuestionFlags (
  33   IN UINT8                   Flags
  34   )
  35 {
  36   return (BOOLEAN) ((Flags & (~QUESTION_FLAGS)) ? FALSE : TRUE);
  37 }
  38
  39 STATIC
  40 BOOLEAN
  41 IsValidValueType (
  42   IN UINT8                   Type
  43   )
  44 {
  45   return (BOOLEAN) ((Type <= EFI_IFR_TYPE_OTHER) ? TRUE : FALSE);
  46 }
  47
  48 STATIC
  49 BOOLEAN
  50 IsValidNumricFlags (
  51   IN UINT8                   Flags
  52   )
  53 {
  54   if (Flags & ~(EFI_IFR_NUMERIC_SIZE | EFI_IFR_DISPLAY)) {
  55     return FALSE;
  56   }
  57
  58   if ((Flags & EFI_IFR_DISPLAY) > EFI_IFR_DISPLAY_UINT_HEX) {
  59     return FALSE;
  60   }
  61
  62   return TRUE;
  63 }
  64
  65 STATIC
  66 BOOLEAN
  67 IsValidCheckboxFlags (
  68   IN UINT8                   Flags
  69   )
  70 {
  71   return (BOOLEAN) ((Flags <= EFI_IFR_CHECKBOX_DEFAULT_MFG) ? TRUE : FALSE);
  72 }
  73
  74 EFI_STATUS
  75 CreateEndOpCode (
  76   IN OUT EFI_HII_UPDATE_DATA *Data
  77   )
  78 {
  79   EFI_IFR_END                 End;
  80   UINT8                       *LocalBuffer;
  81
  82   ASSERT (Data != NULL && Data->Data != NULL);
  83
  84   if (Data->Offset + sizeof (EFI_IFR_END) > Data->BufferSize) {
  85     return EFI_BUFFER_TOO_SMALL;
  86   }
  87
  88   End.Header.Length  = sizeof (EFI_IFR_END);
  89   End.Header.OpCode  = EFI_IFR_END_OP;
  90   End.Header.Scope   = 0;
  91
  92   LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
  93   CopyMem (LocalBuffer, &End, sizeof (EFI_IFR_END));
  94   Data->Offset += sizeof (EFI_IFR_END);
  95
  96   return EFI_SUCCESS;
  97 }
  98
  99 EFI_STATUS
 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 CreateActionOpCode (
 135   IN     EFI_QUESTION_ID      QuestionId,
 136   IN     EFI_STRING_ID        Prompt,
 137   IN     EFI_STRING_ID        Help,
 138   IN     UINT8                QuestionFlags,
 139   IN     EFI_STRING_ID        QuestionConfig,
 140   IN OUT EFI_HII_UPDATE_DATA  *Data
 141   )
 142 {
 143   EFI_IFR_ACTION              Action;
 144   UINT8                       *LocalBuffer;
 145
 146   ASSERT (Data != NULL && Data->Data != NULL);
 147
 148   if (!IsValidQuestionFlags (QuestionFlags)) {
 149     return EFI_INVALID_PARAMETER;
 150   }
 151
 152   if (Data->Offset + sizeof (EFI_IFR_ACTION) > Data->BufferSize) {
 153     return EFI_BUFFER_TOO_SMALL;
 154   }
 155
 156   Action.Header.OpCode          = EFI_IFR_ACTION_OP;
 157   Action.Header.Length          = sizeof (EFI_IFR_ACTION);
 158   Action.Header.Scope           = 0;
 159   Action.Question.QuestionId    = QuestionId;
 160   Action.Question.Header.Prompt = Prompt;
 161   Action.Question.Header.Help   = Help;
 162   Action.Question.VarStoreId    = INVALID_VARSTORE_ID;
 163   Action.Question.Flags         = QuestionFlags;
 164   Action.QuestionConfig         = QuestionConfig;
 165
 166   LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
 167   CopyMem (LocalBuffer, &Action, sizeof (EFI_IFR_ACTION));
 168   Data->Offset += sizeof (EFI_IFR_ACTION);
 169
 170   return EFI_SUCCESS;
 171 }
 172
 173 EFI_STATUS
 174 CreateSubTitleOpCode (
 175   IN      EFI_STRING_ID       Prompt,
 176   IN      EFI_STRING_ID       Help,
 177   IN      UINT8               Flags,
 178   IN      UINT8               Scope,
 179   IN OUT EFI_HII_UPDATE_DATA  *Data
 180   )
 181 {
 182   EFI_IFR_SUBTITLE            Subtitle;
 183   UINT8                       *LocalBuffer;
 184
 185   ASSERT (Data != NULL && Data->Data != NULL);
 186
 187   if (Data->Offset + sizeof (EFI_IFR_SUBTITLE) > Data->BufferSize) {
 188     return EFI_BUFFER_TOO_SMALL;
 189   }
 190
 191   Subtitle.Header.OpCode    = EFI_IFR_SUBTITLE_OP;
 192   Subtitle.Header.Length    = sizeof (EFI_IFR_SUBTITLE);
 193   Subtitle.Header.Scope     = Scope;
 194   Subtitle.Statement.Prompt = Prompt;
 195   Subtitle.Statement.Help   = Help;
 196   Subtitle.Flags            = Flags;
 197
 198   LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
 199   CopyMem (LocalBuffer, &Subtitle, sizeof (EFI_IFR_SUBTITLE));
 200   Data->Offset += sizeof (EFI_IFR_SUBTITLE);
 201
 202   return EFI_SUCCESS;
 203 }
 204
 205
 206 EFI_STATUS
 207 CreateTextOpCode (
 208   IN     EFI_STRING_ID        Prompt,
 209   IN     EFI_STRING_ID        Help,
 210   IN     EFI_STRING_ID        TextTwo,
 211   IN OUT EFI_HII_UPDATE_DATA  *Data
 212   )
 213 {
 214   EFI_IFR_TEXT                Text;
 215   UINT8                       *LocalBuffer;
 216
 217   ASSERT (Data != NULL && Data->Data != NULL);
 218
 219   if (Data->Offset + sizeof (EFI_IFR_TEXT) > Data->BufferSize) {
 220     return EFI_BUFFER_TOO_SMALL;
 221   }
 222
 223   Text.Header.OpCode    = EFI_IFR_TEXT_OP;
 224   Text.Header.Length    = sizeof (EFI_IFR_TEXT);
 225   Text.Header.Scope     = 0;
 226   Text.Statement.Prompt = Prompt;
 227   Text.Statement.Help   = Help;
 228   Text.TextTwo          = TextTwo;
 229
 230   LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
 231   CopyMem (LocalBuffer, &Text, sizeof (EFI_IFR_TEXT));
 232   Data->Offset += sizeof (EFI_IFR_TEXT);
 233
 234   return EFI_SUCCESS;
 235 }
 236
 237 EFI_STATUS
 238 CreateGotoOpCode (
 239   IN     EFI_FORM_ID          FormId,
 240   IN     EFI_STRING_ID        Prompt,
 241   IN     EFI_STRING_ID        Help,
 242   IN     UINT8                QuestionFlags,
 243   IN     EFI_QUESTION_ID      QuestionId,
 244   IN OUT EFI_HII_UPDATE_DATA  *Data
 245   )
 246 {
 247   EFI_IFR_REF                 Goto;
 248   UINT8                       *LocalBuffer;
 249
 250   ASSERT (Data != NULL && Data->Data != NULL);
 251
 252   if (!IsValidQuestionFlags (QuestionFlags)) {
 253     return EFI_INVALID_PARAMETER;
 254   }
 255
 256   if (Data->Offset + sizeof (EFI_IFR_REF) > Data->BufferSize) {
 257     return EFI_BUFFER_TOO_SMALL;
 258   }
 259
 260   Goto.Header.OpCode          = EFI_IFR_REF_OP;
 261   Goto.Header.Length          = sizeof (EFI_IFR_REF);
 262   Goto.Header.Scope           = 0;
 263   Goto.Question.Header.Prompt = Prompt;
 264   Goto.Question.Header.Help   = Help;
 265   Goto.Question.VarStoreId    = INVALID_VARSTORE_ID;
 266   Goto.Question.QuestionId    = QuestionId;
 267   Goto.Question.Flags         = QuestionFlags;
 268   Goto.FormId                 = FormId;
 269
 270   LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
 271   CopyMem (LocalBuffer, &Goto, sizeof (EFI_IFR_REF));
 272   Data->Offset += sizeof (EFI_IFR_REF);
 273
 274   return EFI_SUCCESS;
 275 }
 276
 277 EFI_STATUS
 278 CreateOneOfOptionOpCode (
 279   IN     UINTN                OptionCount,
 280   IN     IFR_OPTION           *OptionsList,
 281   IN     UINT8                Type,
 282   IN OUT EFI_HII_UPDATE_DATA  *Data
 283   )
 284 {
 285   UINTN                       Index;
 286   UINT8                       *LocalBuffer;
 287   EFI_IFR_ONE_OF_OPTION       OneOfOption;
 288
 289   ASSERT (Data != NULL && Data->Data != NULL);
 290
 291   if ((OptionCount != 0) && (OptionsList == NULL)) {
 292     return EFI_INVALID_PARAMETER;
 293   }
 294
 295   if (Data->Offset + OptionCount * sizeof (EFI_IFR_ONE_OF_OPTION) > Data->BufferSize) {
 296     return EFI_BUFFER_TOO_SMALL;
 297   }
 298
 299   for (Index = 0; Index < OptionCount; Index++) {
 300     OneOfOption.Header.OpCode = EFI_IFR_ONE_OF_OPTION_OP;
 301     OneOfOption.Header.Length = sizeof (EFI_IFR_ONE_OF_OPTION);
 302     OneOfOption.Header.Scope  = 0;
 303
 304     OneOfOption.Option        = OptionsList[Index].StringToken;
 305     OneOfOption.Value         = OptionsList[Index].Value;
 306     OneOfOption.Flags         = (UINT8) (OptionsList[Index].Flags & (EFI_IFR_OPTION_DEFAULT | EFI_IFR_OPTION_DEFAULT_MFG));
 307     OneOfOption.Type          = Type;
 308
 309     LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
 310     CopyMem (LocalBuffer, &OneOfOption, sizeof (EFI_IFR_ONE_OF_OPTION));
 311     Data->Offset += sizeof (EFI_IFR_ONE_OF_OPTION);
 312   }
 313
 314   return EFI_SUCCESS;
 315 }
 316
 317 EFI_STATUS
 318 CreateOneOfOpCode (
 319   IN     EFI_QUESTION_ID      QuestionId,
 320   IN     EFI_VARSTORE_ID      VarStoreId,
 321   IN     UINT16               VarOffset,
 322   IN     EFI_STRING_ID        Prompt,
 323   IN     EFI_STRING_ID        Help,
 324   IN     UINT8                QuestionFlags,
 325   IN     UINT8                OneOfFlags,
 326   IN     IFR_OPTION           *OptionsList,
 327   IN     UINTN                OptionCount,
 328   IN OUT EFI_HII_UPDATE_DATA  *Data
 329   )
 330 {
 331   UINTN                       Length;
 332   EFI_IFR_ONE_OF              OneOf;
 333   UINT8                       *LocalBuffer;
 334
 335   ASSERT (Data != NULL && Data->Data != NULL);
 336
 337   if (!IsValidNumricFlags (OneOfFlags) ||
 338       !IsValidQuestionFlags (QuestionFlags) ||
 339       ((OptionCount != 0) && (OptionsList == NULL))) {
 340     return EFI_INVALID_PARAMETER;
 341   }
 342
 343   Length = sizeof (EFI_IFR_ONE_OF) + OptionCount * sizeof (EFI_IFR_ONE_OF_OPTION) + sizeof (EFI_IFR_END);
 344   if (Data->Offset + Length > Data->BufferSize) {
 345     return EFI_BUFFER_TOO_SMALL;
 346   }
 347
 348   OneOf.Header.OpCode                   = EFI_IFR_ONE_OF_OP;
 349   OneOf.Header.Length                   = sizeof (EFI_IFR_ONE_OF);
 350   OneOf.Header.Scope                    = 1;
 351   OneOf.Question.Header.Prompt          = Prompt;
 352   OneOf.Question.Header.Help            = Help;
 353   OneOf.Question.QuestionId             = QuestionId;
 354   OneOf.Question.VarStoreId             = VarStoreId;
 355   OneOf.Question.VarStoreInfo.VarOffset = VarOffset;
 356   OneOf.Question.Flags                  = QuestionFlags;
 357   OneOf.Flags                           = OneOfFlags;
 358   ZeroMem ((VOID *) &OneOf.data, sizeof (MINMAXSTEP_DATA));
 359
 360   LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
 361   CopyMem (LocalBuffer, &OneOf, sizeof (EFI_IFR_ONE_OF));
 362   Data->Offset += sizeof (EFI_IFR_ONE_OF);
 363
 364   CreateOneOfOptionOpCode (OptionCount, OptionsList, (UINT8) (OneOfFlags & EFI_IFR_NUMERIC_SIZE), Data);
 365
 366   CreateEndOpCode (Data);
 367
 368   return EFI_SUCCESS;
 369 }
 370
 371 EFI_STATUS
 372 CreateOrderedListOpCode (
 373   IN      EFI_QUESTION_ID     QuestionId,
 374   IN      EFI_VARSTORE_ID     VarStoreId,
 375   IN      UINT16              VarOffset,
 376   IN      EFI_STRING_ID       Prompt,
 377   IN      EFI_STRING_ID       Help,
 378   IN      UINT8               QuestionFlags,
 379   IN      UINT8               OrderedListFlags,
 380   IN      UINT8               DataType,
 381   IN      UINT8               MaxContainers,
 382   IN      IFR_OPTION          *OptionsList,
 383   IN     UINTN                OptionCount,
 384   IN OUT EFI_HII_UPDATE_DATA  *Data
 385   )
 386 {
 387   UINTN                       Length;
 388   EFI_IFR_ORDERED_LIST        OrderedList;
 389   UINT8                       *LocalBuffer;
 390
 391   ASSERT (Data != NULL && Data->Data != NULL);
 392
 393   if (!IsValidQuestionFlags (QuestionFlags) ||
 394       ((OptionCount != 0) && (OptionsList == NULL))) {
 395     return EFI_INVALID_PARAMETER;
 396   }
 397
 398   if ((OrderedListFlags != 0) &&
 399       (OrderedListFlags != EFI_IFR_UNIQUE_SET) &&
 400       (OrderedListFlags != EFI_IFR_NO_EMPTY_SET)) {
 401     return EFI_INVALID_PARAMETER;
 402   }
 403
 404   Length = sizeof (EFI_IFR_ORDERED_LIST) + OptionCount * sizeof (EFI_IFR_ONE_OF_OPTION) + sizeof (EFI_IFR_END);
 405   if (Data->Offset + Length > Data->BufferSize) {
 406     return EFI_BUFFER_TOO_SMALL;
 407   }
 408
 409   OrderedList.Header.OpCode                   = EFI_IFR_ORDERED_LIST_OP;
 410   OrderedList.Header.Length                   = sizeof (EFI_IFR_ORDERED_LIST);
 411   OrderedList.Header.Scope                    = 1;
 412   OrderedList.Question.Header.Prompt          = Prompt;
 413   OrderedList.Question.Header.Help            = Help;
 414   OrderedList.Question.QuestionId             = QuestionId;
 415   OrderedList.Question.VarStoreId             = VarStoreId;
 416   OrderedList.Question.VarStoreInfo.VarOffset = VarOffset;
 417   OrderedList.Question.Flags                  = QuestionFlags;
 418   OrderedList.MaxContainers                   = MaxContainers;
 419   OrderedList.Flags                           = OrderedListFlags;
 420
 421   LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
 422   CopyMem (LocalBuffer, &OrderedList, sizeof (EFI_IFR_ORDERED_LIST));
 423   Data->Offset += sizeof (EFI_IFR_ORDERED_LIST);
 424
 425   CreateOneOfOptionOpCode (OptionCount, OptionsList, DataType, Data);
 426
 427   CreateEndOpCode (Data);
 428
 429   return EFI_SUCCESS;
 430 }
 431
 432 EFI_STATUS
 433 CreateCheckBoxOpCode (
 434   IN      EFI_QUESTION_ID     QuestionId,
 435   IN      EFI_VARSTORE_ID     VarStoreId,
 436   IN      UINT16              VarOffset,
 437   IN      EFI_STRING_ID       Prompt,
 438   IN      EFI_STRING_ID       Help,
 439   IN      UINT8               QuestionFlags,
 440   IN      UINT8               CheckBoxFlags,
 441   IN OUT EFI_HII_UPDATE_DATA  *Data
 442   )
 443 {
 444   EFI_IFR_CHECKBOX            CheckBox;
 445   UINT8                       *LocalBuffer;
 446
 447   ASSERT (Data != NULL && Data->Data != NULL);
 448
 449   if (!IsValidQuestionFlags (QuestionFlags) || !IsValidCheckboxFlags (CheckBoxFlags)) {
 450     return EFI_INVALID_PARAMETER;
 451   }
 452
 453   if (Data->Offset + sizeof (EFI_IFR_CHECKBOX) > Data->BufferSize) {
 454     return EFI_BUFFER_TOO_SMALL;
 455   }
 456
 457   CheckBox.Header.OpCode                   = EFI_IFR_CHECKBOX_OP;
 458   CheckBox.Header.Length                   = sizeof (EFI_IFR_CHECKBOX);
 459   CheckBox.Header.Scope                    = 0;
 460   CheckBox.Question.QuestionId             = QuestionId;
 461   CheckBox.Question.VarStoreId             = VarStoreId;
 462   CheckBox.Question.VarStoreInfo.VarOffset = VarOffset;
 463   CheckBox.Question.Header.Prompt          = Prompt;
 464   CheckBox.Question.Header.Help            = Help;
 465   CheckBox.Question.Flags                  = QuestionFlags;
 466   CheckBox.Flags                           = CheckBoxFlags;
 467
 468   LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
 469   CopyMem (LocalBuffer, &CheckBox, sizeof (EFI_IFR_CHECKBOX));
 470   Data->Offset += sizeof (EFI_IFR_CHECKBOX);
 471
 472   return EFI_SUCCESS;
 473 }
 474
 475 EFI_STATUS
 476 CreateNumericOpCode (
 477   IN     EFI_QUESTION_ID     QuestionId,
 478   IN     EFI_VARSTORE_ID     VarStoreId,
 479   IN     UINT16              VarOffset,
 480   IN     EFI_STRING_ID       Prompt,
 481   IN     EFI_STRING_ID       Help,
 482   IN     UINT8               QuestionFlags,
 483   IN     UINT8               NumericFlags,
 484   IN     UINT64              Minimum,
 485   IN     UINT64              Maximum,
 486   IN     UINT64              Step,
 487   IN     UINT64              Default,
 488   IN OUT EFI_HII_UPDATE_DATA *Data
 489   )
 490 {
 491   EFI_STATUS                  Status;
 492   EFI_IFR_NUMERIC             Numeric;
 493   MINMAXSTEP_DATA             MinMaxStep;
 494   EFI_IFR_TYPE_VALUE          DefaultValue;
 495   UINT8                       *LocalBuffer;
 496
 497   ASSERT (Data != NULL && Data->Data != NULL);
 498
 499   if (!IsValidQuestionFlags (QuestionFlags) || !IsValidNumricFlags (NumericFlags)) {
 500     return EFI_INVALID_PARAMETER;
 501   }
 502
 503   if (Data->Offset + sizeof (EFI_IFR_CHECKBOX) > Data->BufferSize) {
 504     return EFI_BUFFER_TOO_SMALL;
 505   }
 506
 507   Numeric.Header.OpCode                   = EFI_IFR_NUMERIC_OP;
 508   Numeric.Header.Length                   = sizeof (EFI_IFR_NUMERIC);
 509   Numeric.Header.Scope                    = 1;
 510   Numeric.Question.QuestionId             = QuestionId;
 511   Numeric.Question.VarStoreId             = VarStoreId;
 512   Numeric.Question.VarStoreInfo.VarOffset = VarOffset;
 513   Numeric.Question.Header.Prompt          = Prompt;
 514   Numeric.Question.Header.Help            = Help;
 515   Numeric.Question.Flags                  = QuestionFlags;
 516   Numeric.Flags                           = NumericFlags;
 517
 518   switch (NumericFlags & EFI_IFR_NUMERIC_SIZE) {
 519   case EFI_IFR_NUMERIC_SIZE_1:
 520     MinMaxStep.u8.MinValue = (UINT8) Minimum;
 521     MinMaxStep.u8.MaxValue = (UINT8) Maximum;
 522     MinMaxStep.u8.Step     = (UINT8) Step;
 523     break;
 524
 525   case EFI_IFR_NUMERIC_SIZE_2:
 526     MinMaxStep.u16.MinValue = (UINT16) Minimum;
 527     MinMaxStep.u16.MaxValue = (UINT16) Maximum;
 528     MinMaxStep.u16.Step     = (UINT16) Step;
 529     break;
 530
 531   case EFI_IFR_NUMERIC_SIZE_4:
 532     MinMaxStep.u32.MinValue = (UINT32) Minimum;
 533     MinMaxStep.u32.MaxValue = (UINT32) Maximum;
 534     MinMaxStep.u32.Step     = (UINT32) Step;
 535     break;
 536
 537   case EFI_IFR_NUMERIC_SIZE_8:
 538     MinMaxStep.u64.MinValue = Minimum;
 539     MinMaxStep.u64.MaxValue = Maximum;
 540     MinMaxStep.u64.Step     = Step;
 541     break;
 542   }
 543
 544   CopyMem (&Numeric.data, &MinMaxStep, sizeof (MINMAXSTEP_DATA));
 545
 546   LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
 547   CopyMem (LocalBuffer, &Numeric, sizeof (EFI_IFR_NUMERIC));
 548   Data->Offset += sizeof (EFI_IFR_NUMERIC);
 549
 550   DefaultValue.u64 = Default;
 551   Status = CreateDefaultOpCode (&DefaultValue, (UINT8) (NumericFlags & EFI_IFR_NUMERIC_SIZE), Data);
 552   if (EFI_ERROR(Status)) {
 553     return Status;
 554   }
 555
 556   CreateEndOpCode (Data);
 557
 558   return EFI_SUCCESS;
 559 }
 560
 561 EFI_STATUS
 562 CreateStringOpCode (
 563   IN      EFI_QUESTION_ID     QuestionId,
 564   IN      EFI_VARSTORE_ID     VarStoreId,
 565   IN      UINT16              VarOffset,
 566   IN      EFI_STRING_ID       Prompt,
 567   IN      EFI_STRING_ID       Help,
 568   IN      UINT8               QuestionFlags,
 569   IN      UINT8               StringFlags,
 570   IN      UINT8               MinSize,
 571   IN      UINT8               MaxSize,
 572   IN OUT EFI_HII_UPDATE_DATA  *Data
 573   )
 574 {
 575   EFI_IFR_STRING              String;
 576   UINT8                       *LocalBuffer;
 577
 578   ASSERT (Data != NULL && Data->Data != NULL);
 579
 580   if (!IsValidQuestionFlags (QuestionFlags) || (StringFlags & (~EFI_IFR_STRING_MULTI_LINE))) {
 581     return EFI_INVALID_PARAMETER;
 582   }
 583
 584   if (Data->Offset + sizeof (EFI_IFR_STRING) > Data->BufferSize) {
 585     return EFI_BUFFER_TOO_SMALL;
 586   }
 587
 588   String.Header.OpCode                   = EFI_IFR_STRING_OP;
 589   String.Header.Length                   = sizeof (EFI_IFR_STRING);
 590   String.Header.Scope                    = 0;
 591   String.Question.Header.Prompt          = Prompt;
 592   String.Question.Header.Help            = Help;
 593   String.Question.QuestionId             = QuestionId;
 594   String.Question.VarStoreId             = VarStoreId;
 595   String.Question.VarStoreInfo.VarOffset = VarOffset;
 596   String.Question.Flags                  = QuestionFlags;
 597   String.MinSize                         = MinSize;
 598   String.MaxSize                         = MaxSize;
 599   String.Flags                           = StringFlags;
 600
 601   LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
 602   CopyMem (LocalBuffer, &String, sizeof (EFI_IFR_STRING));
 603   Data->Offset += sizeof (EFI_IFR_STRING);
 604
 605   return EFI_SUCCESS;
 606 }
 607
 608 EFI_STATUS
 609 CreateBannerOpCode (
 610   IN      EFI_STRING_ID       Title,
 611   IN      UINT16              LineNumber,
 612   IN      UINT8               Alignment,
 613   IN OUT EFI_HII_UPDATE_DATA  *Data
 614   )
 615 {
 616   EFI_IFR_GUID_BANNER         Banner;
 617   UINT8                       *LocalBuffer;
 618
 619   ASSERT (Data != NULL && Data->Data != NULL);
 620
 621   if (Data->Offset + sizeof (EFI_IFR_GUID_BANNER) > Data->BufferSize) {
 622     return EFI_BUFFER_TOO_SMALL;
 623   }
 624
 625   Banner.Header.OpCode  = EFI_IFR_GUID_OP;
 626   Banner.Header.Length  = sizeof (EFI_IFR_GUID_BANNER);
 627   Banner.Header.Scope   = 0;
 628   CopyMem (&Banner.Guid, &mIfrVendorGuid, sizeof (EFI_IFR_GUID));
 629   Banner.ExtendOpCode   = EFI_IFR_EXTEND_OP_BANNER;
 630   Banner.Title          = Title;
 631   Banner.LineNumber     = LineNumber;
 632   Banner.Alignment      = Alignment;
 633
 634   LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
 635   CopyMem (LocalBuffer, &Banner, sizeof (EFI_IFR_GUID_BANNER));
 636   Data->Offset += sizeof (EFI_IFR_GUID_BANNER);
 637
 638   return EFI_SUCCESS;
 639 }