EdkCompatibilityPkg/Compatibility/FrameworkHiiToUefiHiiThunk/OpcodeCreation.c

   1 /** @file
   2 Implement Functions to convert IFR Opcode in format defined in Framework HII specification to
   3 format defined in UEFI HII Specification.
   4
   5 Copyright (c) 2007, Intel Corporation
   6 All rights reserved. This program and the accompanying materials
   7 are licensed and made available under the terms and conditions of the BSD License
   8 which accompanies this distribution.  The full text of the license may be found at
   9 http://opensource.org/licenses/bsd-license.php
  10
  11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15 #include "HiiDatabase.h"
  16 #include "OpcodeCreation.h"
  17 #include "UefiIfrDefault.h"
  18
  19 EFI_GUID  mTianoExtendedOpcodeGuid = EFI_IFR_TIANO_GUID;
  20
  21
  22 EFI_IFR_GUID_OPTIONKEY mOptionKeyTemplate = {
  23    {EFI_IFR_GUID_OP, sizeof (EFI_IFR_GUID_OPTIONKEY), 0},
  24    EFI_IFR_FRAMEWORK_GUID,
  25    EFI_IFR_EXTEND_OP_OPTIONKEY,
  26    0,
  27    {0},
  28    0
  29 };
  30
  31 typedef struct {
  32   UINT8 FrameworkIfrOp;
  33   UINT8 UefiIfrOp;
  34 } IFR_OPCODE_MAP;
  35
  36 IFR_OPCODE_MAP mQuestionOpcodeMap [] = {
  37   { FRAMEWORK_EFI_IFR_ONE_OF_OP,        EFI_IFR_ONE_OF_OP},
  38   { FRAMEWORK_EFI_IFR_CHECKBOX_OP,      EFI_IFR_CHECKBOX_OP},
  39   { FRAMEWORK_EFI_IFR_NUMERIC_OP,       EFI_IFR_NUMERIC_OP},
  40   { FRAMEWORK_EFI_IFR_ONE_OF_OPTION_OP, EFI_IFR_ONE_OF_OPTION_OP},
  41   { FRAMEWORK_EFI_IFR_ORDERED_LIST_OP,  EFI_IFR_ORDERED_LIST_OP}
  42 };
  43
  44 EFI_STATUS
  45 QuestionOpFwToUefi (
  46   IN            UINT8   FwOp,
  47   OUT           UINT8   *UefiOp
  48   )
  49 {
  50   UINTN       Index;
  51
  52   for (Index = 0; Index < sizeof (mQuestionOpcodeMap) / sizeof (mQuestionOpcodeMap[0]); Index++) {
  53     if (FwOp == mQuestionOpcodeMap[Index].FrameworkIfrOp) {
  54       *UefiOp = mQuestionOpcodeMap[Index].UefiIfrOp;
  55       return EFI_SUCCESS;
  56     }
  57   }
  58
  59   *UefiOp = (UINT8) (FRAMEWORK_EFI_IFR_LAST_OPCODE + 1);
  60   return EFI_NOT_FOUND;
  61 }
  62
  63
  64 EFI_STATUS
  65 FwQIdToUefiQId (
  66   IN  CONST FORM_BROWSER_FORMSET *FormSet,
  67   IN  UINT16                     VarStoreId,
  68   IN  UINT8                      FwOpCode,
  69   IN  UINT16                     FwQId,
  70   OUT UINT16                     *UefiQId
  71   )
  72 {
  73   LIST_ENTRY             *FormList;
  74   LIST_ENTRY             *StatementList;
  75   FORM_BROWSER_FORM      *Form;
  76   FORM_BROWSER_STATEMENT *Statement;
  77   EFI_STATUS             Status;
  78   UINT8                  UefiOp;
  79
  80   *UefiQId = 0;
  81
  82   FormList = GetFirstNode (&FormSet->FormListHead);
  83
  84   while (!IsNull (&FormSet->FormListHead, FormList)) {
  85     Form = FORM_BROWSER_FORM_FROM_LINK (FormList);
  86
  87     StatementList = GetFirstNode (&Form->StatementListHead);
  88
  89     while (!IsNull (&Form->StatementListHead, StatementList)) {
  90       Statement = FORM_BROWSER_STATEMENT_FROM_LINK (StatementList);
  91       if (Statement->VarStoreId != 0 && Statement->Storage->Type == EFI_HII_VARSTORE_BUFFER) {
  92         if (FwQId == Statement->VarStoreInfo.VarOffset) {
  93           Status = QuestionOpFwToUefi (FwOpCode, &UefiOp);
  94           ASSERT_EFI_ERROR (Status);
  95
  96           if (UefiOp == Statement->Operand) {
  97             //
  98             // If ASSERT here, the Framework VFR file has two IFR Question with the Same Type refering to the
  99             // same field in NvMap. This is ambigurity, we don't handle it for now.
 100             //
 101             //
 102             // UEFI Question ID is unique in a FormSet.
 103             //
 104             ASSERT (VarStoreId == Statement->VarStoreId);
 105             *UefiQId = Statement->QuestionId;
 106
 107             return EFI_SUCCESS;
 108
 109           }
 110         }
 111       }
 112
 113       StatementList = GetNextNode (&Form->StatementListHead, StatementList);
 114     }
 115
 116     FormList = GetNextNode (&FormSet->FormListHead, FormList);
 117   }
 118
 119   return EFI_NOT_FOUND;
 120 }
 121
 122
 123
 124 #define LOCAL_UPDATE_DATA_BUFFER_INCREMENTAL   0x1000
 125 EFI_STATUS
 126 AppendToUpdateBuffer (
 127   IN CONST  UINT8                *OpCodeBuf,
 128   IN        UINTN                BufSize,
 129   OUT       EFI_HII_UPDATE_DATA  *UefiData
 130   )
 131 {
 132   UINT8 * NewBuff;
 133
 134   if (UefiData->Offset + BufSize > UefiData->BufferSize) {
 135     NewBuff = AllocateCopyPool (UefiData->BufferSize + LOCAL_UPDATE_DATA_BUFFER_INCREMENTAL, UefiData->Data);
 136     if (NewBuff == NULL) {
 137       return EFI_OUT_OF_RESOURCES;
 138     }
 139     UefiData->BufferSize += LOCAL_UPDATE_DATA_BUFFER_INCREMENTAL;
 140     FreePool (UefiData->Data);
 141     UefiData->Data = NewBuff;
 142   }
 143
 144   CopyMem (UefiData->Data + UefiData->Offset, OpCodeBuf, BufSize);
 145   UefiData->Offset += (UINT32) BufSize;
 146
 147   return EFI_SUCCESS;
 148 }
 149
 150 EFI_QUESTION_ID
 151 AssignQuestionId (
 152   IN  UINT16                      FwQuestionId,
 153   IN        FORM_BROWSER_FORMSET  *FormSet
 154   )
 155 {
 156   if (FwQuestionId == 0) {
 157     FormSet->MaxQuestionId++;
 158     return FormSet->MaxQuestionId;
 159   } else {
 160     return FwQuestionId;
 161   }
 162 }
 163
 164 EFI_STATUS
 165 UCreateEndOfOpcode (
 166   OUT      EFI_HII_UPDATE_DATA         *UefiData
 167   )
 168 {
 169   EFI_IFR_END UOpcode;
 170
 171   ZeroMem (&UOpcode, sizeof (UOpcode));
 172
 173   UOpcode.Header.OpCode = EFI_IFR_END_OP;
 174   UOpcode.Header.Length = sizeof (UOpcode);
 175
 176   return AppendToUpdateBuffer ((UINT8 *)&UOpcode, sizeof(UOpcode), UefiData);
 177 }
 178
 179 EFI_STATUS
 180 F2UCreateSubtitleOpCode (
 181   IN CONST FRAMEWORK_EFI_IFR_SUBTITLE  *FwSubTitle,
 182   OUT      EFI_HII_UPDATE_DATA         *UefiData
 183   )
 184 {
 185   EFI_IFR_SUBTITLE UOpcode;
 186
 187   ZeroMem (&UOpcode, sizeof(UOpcode));
 188
 189   UOpcode.Header.OpCode = EFI_IFR_SUBTITLE_OP;
 190   UOpcode.Header.Length = sizeof (EFI_IFR_SUBTITLE);
 191
 192   UOpcode.Statement.Prompt = FwSubTitle->SubTitle;
 193
 194   return AppendToUpdateBuffer ((UINT8 *)&UOpcode, sizeof(UOpcode), UefiData);
 195 }
 196
 197 EFI_STATUS
 198 F2UCreateTextOpCode (
 199   IN CONST FRAMEWORK_EFI_IFR_TEXT      *FwText,
 200   OUT      EFI_HII_UPDATE_DATA         *UefiData
 201   )
 202 {
 203   EFI_IFR_TEXT      UTextOpCode;
 204   EFI_IFR_ACTION    UActionOpCode;
 205
 206   if ((FwText->Flags & FRAMEWORK_EFI_IFR_FLAG_INTERACTIVE) == 0) {
 207     ZeroMem (&UTextOpCode, sizeof(UTextOpCode));
 208
 209     UTextOpCode.Header.OpCode = EFI_IFR_TEXT_OP;
 210     UTextOpCode.Header.Length = sizeof (EFI_IFR_TEXT);
 211
 212     UTextOpCode.Statement.Help   = FwText->Help;
 213
 214     UTextOpCode.Statement.Prompt = FwText->Text;
 215     UTextOpCode.TextTwo          = FwText->TextTwo;
 216
 217     return AppendToUpdateBuffer ((UINT8 *) &UTextOpCode, sizeof(UTextOpCode), UefiData);
 218   } else {
 219     //
 220     // Iteractive Text Opcode is EFI_IFR_ACTION
 221     //
 222
 223     ZeroMem (&UActionOpCode, sizeof (UActionOpCode));
 224
 225     UActionOpCode.Header.OpCode = EFI_IFR_ACTION_OP;
 226     UActionOpCode.Header.Length = sizeof (EFI_IFR_ACTION);
 227
 228     UActionOpCode.Question.Header.Prompt = FwText->Text;
 229     UActionOpCode.Question.Header.Help  = FwText->Help;
 230     UActionOpCode.Question.Flags      = EFI_IFR_FLAG_CALLBACK;
 231     UActionOpCode.Question.QuestionId = FwText->Key;
 232
 233     return AppendToUpdateBuffer ((UINT8 *) &UActionOpCode, sizeof(UActionOpCode), UefiData);
 234
 235   }
 236 }
 237
 238 /*
 239 typedef struct {
 240   FRAMEWORK_EFI_IFR_OP_HEADER Header;
 241   UINT16            FormId;
 242   STRING_REF        Prompt;
 243   STRING_REF        Help;   // The string Token for the context-help
 244   UINT8             Flags;  // This is included solely for purposes of interactive/dynamic support.
 245   UINT16            Key;    // Value to be passed to caller to identify this particular op-code
 246 } FRAMEWORK_EFI_IFR_REF;
 247
 248 */
 249 EFI_STATUS
 250 F2UCreateGotoOpCode (
 251   IN CONST FRAMEWORK_EFI_IFR_REF       *FwOpcode,
 252   OUT      EFI_HII_UPDATE_DATA         *UefiData
 253   )
 254 {
 255   EFI_IFR_REF UOpcode;
 256
 257   ZeroMem (&UOpcode, sizeof(UOpcode));
 258
 259   UOpcode.Header.Length = sizeof(UOpcode);
 260   UOpcode.Header.OpCode = EFI_IFR_REF_OP;
 261
 262   UOpcode.Question.Header.Prompt = FwOpcode->Prompt;
 263   UOpcode.Question.Header.Help = FwOpcode->Help;
 264   UOpcode.Question.QuestionId = FwOpcode->Key;
 265
 266   UOpcode.FormId = FwOpcode->FormId;
 267
 268   //
 269   // We only map FRAMEWORK_EFI_IFR_FLAG_INTERACTIVE and FRAMEWORK_EFI_IFR_FLAG_RESET_REQUIRED to
 270   // UEFI IFR Opcode flags. The rest flags are obsolete.
 271   //
 272   UOpcode.Question.Flags  = (UINT8) (FwOpcode->Flags & (FRAMEWORK_EFI_IFR_FLAG_INTERACTIVE | FRAMEWORK_EFI_IFR_FLAG_RESET_REQUIRED));
 273
 274
 275   return AppendToUpdateBuffer ((UINT8 *) &UOpcode, sizeof(UOpcode), UefiData);
 276 }
 277
 278
 279 /*
 280 typedef struct {
 281   FRAMEWORK_EFI_IFR_OP_HEADER Header;
 282   STRING_REF        Option;     // The string token describing the option
 283   UINT16            Value;      // The value associated with this option that is stored in the NVRAM if chosen
 284   UINT8             Flags;      // For now, if non-zero, means that it is the default option, - further definition likely above
 285   UINT16            Key;        // Value to be passed to caller to identify this particular op-code
 286 } FRAMEWORK_EFI_IFR_ONE_OF_OPTION;
 287
 288 typedef union {
 289   UINT8           u8;
 290   UINT16          u16;
 291   UINT32          u32;
 292   UINT64          u64;
 293   BOOLEAN         b;
 294   EFI_HII_TIME    time;
 295   EFI_HII_DATE    date;
 296   EFI_STRING_ID   string;
 297 } EFI_IFR_TYPE_VALUE;
 298
 299 typedef struct _EFI_IFR_ONE_OF_OPTION {
 300   EFI_IFR_OP_HEADER        Header;
 301   EFI_STRING_ID            Option;
 302   UINT8                    Flags;
 303   UINT8                    Type;
 304   EFI_IFR_TYPE_VALUE       Value;
 305 } EFI_IFR_ONE_OF_OPTION;
 306
 307 */
 308 EFI_STATUS
 309 F2UCreateOneOfOptionOpCode (
 310   IN CONST FRAMEWORK_EFI_IFR_ONE_OF_OPTION    *FwOpcode,
 311   IN       UINTN                              Width,
 312   OUT      EFI_HII_UPDATE_DATA                *UefiData
 313   )
 314 {
 315   EFI_IFR_ONE_OF_OPTION UOpcode;
 316
 317   ZeroMem (&UOpcode, sizeof(UOpcode));
 318
 319   UOpcode.Header.Length = sizeof(UOpcode);
 320   UOpcode.Header.OpCode = EFI_IFR_ONE_OF_OPTION_OP;
 321
 322   UOpcode.Option        = FwOpcode->Option;
 323   CopyMem (&UOpcode.Value.u8, &FwOpcode->Value, Width);
 324
 325   //
 326
 327   // #define FRAMEWORK_EFI_IFR_FLAG_DEFAULT                    0x01
 328   // #define FRAMEWORK_EFI_IFR_FLAG_MANUFACTURING        0x02
 329   // #define EFI_IFR_OPTION_DEFAULT 0x10
 330   // #define EFI_IFR_OPTION_DEFAULT_MFG 0x20
 331   //
 332   UOpcode.Flags = (UINT8) (UOpcode.Flags  | (FwOpcode->Flags & (FRAMEWORK_EFI_IFR_FLAG_DEFAULT | FRAMEWORK_EFI_IFR_FLAG_MANUFACTURING)) << 4);
 333
 334   switch (Width) {
 335     case 1:
 336       UOpcode.Type = EFI_IFR_TYPE_NUM_SIZE_8;
 337       break;
 338
 339     case 2:
 340       UOpcode.Type = EFI_IFR_TYPE_NUM_SIZE_16;
 341       break;
 342
 343     default:
 344       ASSERT (FALSE);
 345       return EFI_UNSUPPORTED;
 346   }
 347
 348   return AppendToUpdateBuffer ((UINT8 *) &UOpcode, sizeof(UOpcode), UefiData);
 349 }
 350
 351 EFI_STATUS
 352 CreateGuidOptionKeyOpCode (
 353   IN EFI_QUESTION_ID                   QuestionId,
 354   IN UINT16                            OptionValue,
 355   IN EFI_QUESTION_ID                   KeyValue,
 356   OUT      EFI_HII_UPDATE_DATA         *UefiData
 357   )
 358 {
 359   EFI_IFR_GUID_OPTIONKEY              UOpcode;
 360
 361   CopyMem (&UOpcode, &mOptionKeyTemplate, sizeof (EFI_IFR_GUID_OPTIONKEY));
 362
 363   UOpcode.QuestionId  = QuestionId;
 364   CopyMem (&UOpcode.OptionValue, &OptionValue, sizeof (OptionValue));
 365   UOpcode.KeyValue = KeyValue;
 366
 367   return AppendToUpdateBuffer ((UINT8 *) &UOpcode, sizeof(UOpcode), UefiData);
 368 }
 369
 370 /*
 371 typedef struct _EFI_IFR_QUESTION_HEADER {
 372   EFI_IFR_STATEMENT_HEADER Header;
 373   EFI_QUESTION_ID          QuestionId;
 374   EFI_VARSTORE_ID          VarStoreId;
 375   union {
 376     EFI_STRING_ID          VarName;
 377     UINT16                 VarOffset;
 378   }                        VarStoreInfo;
 379   UINT8                    Flags;
 380 } EFI_IFR_QUESTION_HEADER;
 381
 382 typedef union {
 383   struct {
 384     UINT8 MinValue;
 385     UINT8 MaxValue;
 386     UINT8 Step;
 387   } u8;
 388   struct {
 389     UINT16 MinValue;
 390     UINT16 MaxValue;
 391     UINT16 Step;
 392   } u16;
 393   struct {
 394     UINT32 MinValue;
 395     UINT32 MaxValue;
 396     UINT32 Step;
 397   } u32;
 398   struct {
 399     UINT64 MinValue;
 400     UINT64 MaxValue;
 401     UINT64 Step;
 402   } u64;
 403 } MINMAXSTEP_DATA;
 404
 405 typedef struct _EFI_IFR_ONE_OF {
 406   EFI_IFR_OP_HEADER        Header;
 407   EFI_IFR_QUESTION_HEADER  Question;
 408   UINT8                    Flags;
 409   MINMAXSTEP_DATA          data;
 410 } EFI_IFR_ONE_OF;
 411
 412 typedef struct {
 413   FRAMEWORK_EFI_IFR_OP_HEADER Header;
 414   UINT16            QuestionId; // The ID designating what the question is about...sucked in from a #define, likely in the form of a variable name
 415   UINT8             Width;      // The Size of the Data being saved
 416   STRING_REF        Prompt;     // The String Token for the Prompt
 417   STRING_REF        Help;       // The string Token for the context-help
 418 } FRAMEWORK_EFI_IFR_ONE_OF;
 419
 420
 421 */
 422
 423 EFI_STATUS
 424 F2UCreateOneOfOpCode (
 425   IN       HII_THUNK_CONTEXT           *ThunkContext,
 426   IN       UINT16                      VarStoreId,
 427   IN CONST FRAMEWORK_EFI_IFR_ONE_OF    *FwOpcode,
 428   OUT      EFI_HII_UPDATE_DATA         *UefiData,
 429   OUT      FRAMEWORK_EFI_IFR_OP_HEADER **NextFwOpcode,
 430   OUT      UINTN                       *DataCount
 431   )
 432 {
 433   EFI_STATUS                          Status;
 434   EFI_IFR_ONE_OF                      UOpcode;
 435   FRAMEWORK_EFI_IFR_OP_HEADER         *FwOpHeader;
 436   FRAMEWORK_EFI_IFR_ONE_OF_OPTION     *FwOneOfOp;
 437
 438   ASSERT (NextFwOpcode != NULL);
 439   ASSERT (DataCount != NULL);
 440
 441   ZeroMem (&UOpcode, sizeof(UOpcode));
 442   *DataCount = 0;
 443
 444   UOpcode.Header.Length = sizeof(UOpcode);
 445   UOpcode.Header.OpCode = EFI_IFR_ONE_OF_OP;
 446   UOpcode.Header.Scope  = 1;
 447
 448   UOpcode.Question.Header.Prompt = FwOpcode->Prompt;
 449   UOpcode.Question.Header.Help = FwOpcode->Help;
 450   UOpcode.Question.VarStoreId  = VarStoreId;
 451   UOpcode.Question.VarStoreInfo.VarOffset = FwOpcode->QuestionId;
 452
 453   //
 454   // Go over the Framework IFR binary to get the QuestionId for generated UEFI One Of Option opcode
 455   //
 456   FwOpHeader = (FRAMEWORK_EFI_IFR_OP_HEADER *) ((UINT8 *) FwOpcode + FwOpcode->Header.Length);
 457   while (FwOpHeader->OpCode != FRAMEWORK_EFI_IFR_END_ONE_OF_OP) {
 458     ASSERT (FwOpHeader->OpCode == FRAMEWORK_EFI_IFR_ONE_OF_OPTION_OP);
 459
 460     FwOneOfOp = (FRAMEWORK_EFI_IFR_ONE_OF_OPTION *) FwOpHeader;
 461     if ((FwOneOfOp->Flags & FRAMEWORK_EFI_IFR_FLAG_INTERACTIVE) != 0) {
 462       UOpcode.Question.Flags |= EFI_IFR_FLAG_CALLBACK;
 463
 464       if (UOpcode.Question.QuestionId == 0) {
 465         Status = FwQIdToUefiQId (ThunkContext->FormSet, VarStoreId, FwOpcode->Header.OpCode, FwOpcode->QuestionId, &UOpcode.Question.QuestionId);
 466         if (EFI_ERROR (Status)) {
 467           UOpcode.Question.QuestionId = AssignQuestionId (FwOneOfOp->Key, ThunkContext->FormSet);
 468         }
 469       }
 470
 471     }
 472
 473     if (FwOneOfOp->Flags & FRAMEWORK_EFI_IFR_FLAG_RESET_REQUIRED) {
 474       UOpcode.Question.Flags |= EFI_IFR_FLAG_RESET_REQUIRED;
 475     }
 476
 477     FwOpHeader = (FRAMEWORK_EFI_IFR_OP_HEADER *) ((UINT8 *) FwOpHeader + FwOpHeader->Length);
 478   }
 479
 480
 481   if (UOpcode.Question.QuestionId == 0) {
 482     //
 483     // Assign QuestionId if still not assigned.
 484     //
 485     Status = FwQIdToUefiQId (ThunkContext->FormSet, VarStoreId, FwOpcode->Header.OpCode, FwOpcode->QuestionId, &UOpcode.Question.QuestionId);
 486     if (EFI_ERROR (Status)) {
 487       UOpcode.Question.QuestionId = AssignQuestionId (FwOpcode->QuestionId, ThunkContext->FormSet);
 488     }
 489   }
 490
 491   Status = AppendToUpdateBuffer ((UINT8 *) &UOpcode, sizeof (UOpcode), UefiData);
 492   if (EFI_ERROR (Status)) {
 493     return Status;
 494   }
 495   *DataCount += 1;
 496
 497   //
 498   // Go over again the Framework IFR binary to build the UEFI One Of Option opcodes.
 499   //
 500   FwOpHeader = (FRAMEWORK_EFI_IFR_OP_HEADER *) ((UINT8 *) FwOpcode + FwOpcode->Header.Length);
 501   while (FwOpHeader->OpCode != FRAMEWORK_EFI_IFR_END_ONE_OF_OP) {
 502
 503     FwOneOfOp = (FRAMEWORK_EFI_IFR_ONE_OF_OPTION *) FwOpHeader;
 504
 505     Status = F2UCreateOneOfOptionOpCode ((FRAMEWORK_EFI_IFR_ONE_OF_OPTION *) FwOpHeader, FwOpcode->Width, UefiData);
 506     if (EFI_ERROR (Status)) {
 507       return Status;
 508     }
 509
 510     Status = CreateGuidOptionKeyOpCode (UOpcode.Question.QuestionId, FwOneOfOp->Value, FwOneOfOp->Key, UefiData);
 511     if (EFI_ERROR (Status)) {
 512       return Status;
 513     }
 514     FwOpHeader = (FRAMEWORK_EFI_IFR_OP_HEADER *) ((UINT8 *) FwOpHeader + FwOpHeader->Length);
 515     *DataCount += 1;
 516   }
 517
 518   Status = UCreateEndOfOpcode (UefiData);
 519   if (!EFI_ERROR (Status)) {
 520     *NextFwOpcode = (FRAMEWORK_EFI_IFR_OP_HEADER *)((UINT8 *) FwOpHeader + FwOpHeader->Length);
 521     *DataCount += 1;
 522   }
 523
 524   return Status;
 525 }
 526
 527 /*
 528 typedef struct _EFI_IFR_QUESTION_HEADER {
 529   EFI_IFR_STATEMENT_HEADER Header;
 530   EFI_QUESTION_ID          QuestionId;
 531   EFI_VARSTORE_ID          VarStoreId;
 532   union {
 533     EFI_STRING_ID          VarName;
 534     UINT16                 VarOffset;
 535   }                        VarStoreInfo;
 536   UINT8                    Flags;
 537 } EFI_IFR_QUESTION_HEADER;
 538
 539 typedef struct _EFI_IFR_ORDERED_LIST {
 540   EFI_IFR_OP_HEADER        Header;
 541   EFI_IFR_QUESTION_HEADER  Question;
 542   UINT8                    MaxContainers;
 543   UINT8                    Flags;
 544 } EFI_IFR_ORDERED_LIST;
 545
 546 typedef struct {
 547   FRAMEWORK_EFI_IFR_OP_HEADER Header;
 548   UINT16            QuestionId; // The offset in NV for storage of the data
 549   UINT8             MaxEntries; // The maximum number of options in the ordered list (=size of NVStore)
 550   STRING_REF        Prompt;     // The string token for the prompt
 551   STRING_REF        Help;       // The string token for the context-help
 552 } FRAMEWORK_EFI_IFR_ORDERED_LIST;
 553
 554 */
 555 EFI_STATUS
 556 F2UCreateOrderedListOpCode (
 557   IN       HII_THUNK_CONTEXT               *ThunkContext,
 558   IN       UINT16                      VarStoreId,
 559   IN CONST FRAMEWORK_EFI_IFR_ORDERED_LIST *FwOpcode,
 560   OUT      EFI_HII_UPDATE_DATA         *UefiData,
 561   OUT      FRAMEWORK_EFI_IFR_OP_HEADER **NextFwOpcode,
 562   OUT      UINTN                       *DataCount
 563   )
 564 {
 565   EFI_IFR_ORDERED_LIST              UOpcode;
 566   EFI_STATUS                        Status;
 567   FRAMEWORK_EFI_IFR_OP_HEADER       *FwOpHeader;
 568   FRAMEWORK_EFI_IFR_ONE_OF_OPTION     *FwOneOfOp;
 569
 570   ZeroMem (&UOpcode, sizeof(UOpcode));
 571   *DataCount = 0;
 572
 573   UOpcode.Header.Length = sizeof(UOpcode);
 574   UOpcode.Header.OpCode = EFI_IFR_ORDERED_LIST_OP;
 575   UOpcode.Header.Scope  = 1;
 576
 577   UOpcode.Question.Header.Prompt = FwOpcode->Prompt;
 578   UOpcode.Question.Header.Help = FwOpcode->Help;
 579   UOpcode.Question.VarStoreId  = VarStoreId;
 580   UOpcode.Question.VarStoreInfo.VarOffset = FwOpcode->QuestionId;
 581
 582   UOpcode.MaxContainers = FwOpcode->MaxEntries;
 583
 584   //
 585   // Go over the Framework IFR binary to get the QuestionId for generated UEFI One Of Option opcode
 586   //
 587   FwOpHeader = (FRAMEWORK_EFI_IFR_OP_HEADER *) ((UINT8 *) FwOpcode + FwOpcode->Header.Length);
 588   while (FwOpHeader->OpCode != FRAMEWORK_EFI_IFR_END_ONE_OF_OP) {
 589     ASSERT (FwOpHeader->OpCode == FRAMEWORK_EFI_IFR_ONE_OF_OPTION_OP);
 590
 591     FwOneOfOp = (FRAMEWORK_EFI_IFR_ONE_OF_OPTION *) FwOpHeader;
 592     if ((FwOneOfOp->Flags & FRAMEWORK_EFI_IFR_FLAG_INTERACTIVE) != 0) {
 593       UOpcode.Question.Flags |= EFI_IFR_FLAG_CALLBACK;
 594
 595       if (UOpcode.Question.QuestionId == 0) {
 596         Status = FwQIdToUefiQId (ThunkContext->FormSet, VarStoreId, FwOpcode->Header.OpCode, FwOpcode->QuestionId, &UOpcode.Question.QuestionId);
 597         if (EFI_ERROR (Status)) {
 598           UOpcode.Question.QuestionId = AssignQuestionId (FwOneOfOp->Key, ThunkContext->FormSet);
 599         }
 600
 601       }
 602     }
 603
 604     if (FwOneOfOp->Flags & FRAMEWORK_EFI_IFR_FLAG_RESET_REQUIRED) {
 605       UOpcode.Question.Flags |= EFI_IFR_FLAG_RESET_REQUIRED;
 606     }
 607
 608     FwOpHeader = (FRAMEWORK_EFI_IFR_OP_HEADER *) ((UINT8 *) FwOpHeader + FwOpHeader->Length);
 609   }
 610
 611   if (UOpcode.Question.QuestionId == 0) {
 612     Status = FwQIdToUefiQId (ThunkContext->FormSet, VarStoreId, FwOpcode->Header.OpCode, FwOpcode->QuestionId, &UOpcode.Question.QuestionId);
 613     if (EFI_ERROR (Status)) {
 614       UOpcode.Question.QuestionId = AssignQuestionId (FwOpcode->QuestionId, ThunkContext->FormSet);
 615     }
 616   }
 617
 618   Status = AppendToUpdateBuffer ((UINT8 *) &UOpcode, sizeof(UOpcode), UefiData);
 619   if (EFI_ERROR (Status)) {
 620     return Status;
 621   }
 622   *DataCount += 1;
 623
 624   FwOpHeader = (FRAMEWORK_EFI_IFR_OP_HEADER *) ((UINT8 *) FwOpcode + FwOpcode->Header.Length);
 625   while (FwOpHeader->OpCode != FRAMEWORK_EFI_IFR_END_ONE_OF_OP) {
 626     //
 627     // Each entry of Order List in Framework HII is always 1 byte in size
 628     //
 629     Status = F2UCreateOneOfOptionOpCode ((CONST FRAMEWORK_EFI_IFR_ONE_OF_OPTION *) FwOpHeader, 1, UefiData);
 630     if (EFI_ERROR (Status)) {
 631       return Status;
 632     }
 633     FwOpHeader = (FRAMEWORK_EFI_IFR_OP_HEADER *) ((UINT8 *) FwOpHeader + FwOpHeader->Length);
 634     *DataCount += 1;
 635   }
 636
 637   Status = UCreateEndOfOpcode (UefiData);
 638   if (!EFI_ERROR (Status)) {
 639     *NextFwOpcode = (FRAMEWORK_EFI_IFR_OP_HEADER *)((UINT8 *) FwOpHeader + FwOpHeader->Length);
 640     *DataCount += 1;
 641   }
 642
 643   return Status;
 644 }
 645
 646 /*
 647 typedef struct _EFI_IFR_QUESTION_HEADER {
 648   EFI_IFR_STATEMENT_HEADER Header;
 649   EFI_QUESTION_ID          QuestionId;
 650   EFI_VARSTORE_ID          VarStoreId;
 651   union {
 652     EFI_STRING_ID          VarName;
 653     UINT16                 VarOffset;
 654   }                        VarStoreInfo;
 655   UINT8                    Flags;
 656 } EFI_IFR_QUESTION_HEADER;
 657 */
 658
 659 /*
 660 typedef struct _EFI_IFR_CHECKBOX {
 661   EFI_IFR_OP_HEADER        Header;
 662   EFI_IFR_QUESTION_HEADER  Question;
 663   UINT8                    Flags;
 664 } EFI_IFR_CHECKBOX;
 665 */
 666
 667 /*
 668 typedef struct {
 669   FRAMEWORK_EFI_IFR_OP_HEADER Header;
 670   UINT16            QuestionId; // The ID designating what the question is about...sucked in from a #define, likely in the form of a variable name
 671   UINT8             Width;      // The Size of the Data being saved
 672   STRING_REF        Prompt;     // The String Token for the Prompt
 673   STRING_REF        Help;       // The string Token for the context-help
 674   UINT8             Flags;      // For now, if non-zero, means that it is the default option, - further definition likely
 675   UINT16            Key;        // Value to be passed to caller to identify this particular op-code
 676 } FRAMEWORK_EFI_IFR_CHECKBOX, FRAMEWORK_EFI_IFR_CHECK_BOX;
 677 */
 678
 679
 680 EFI_STATUS
 681 F2UCreateCheckBoxOpCode (
 682   IN       HII_THUNK_CONTEXT           *ThunkContext,
 683   IN       UINT16                      VarStoreId,
 684   IN CONST FRAMEWORK_EFI_IFR_CHECKBOX  *FwOpcode,
 685   OUT      EFI_HII_UPDATE_DATA         *UefiData
 686   )
 687 {
 688   EFI_STATUS       Status;
 689   EFI_IFR_CHECKBOX UOpcode;
 690
 691   ZeroMem (&UOpcode, sizeof(UOpcode));
 692
 693   UOpcode.Header.Length = sizeof(UOpcode);
 694   UOpcode.Header.OpCode = EFI_IFR_CHECKBOX_OP;
 695
 696   UOpcode.Question.Header.Prompt = FwOpcode->Prompt;
 697   UOpcode.Question.Header.Help = FwOpcode->Help;
 698
 699   if (FwOpcode->Key == 0) {
 700     Status = FwQIdToUefiQId (ThunkContext->FormSet, VarStoreId, FwOpcode->Header.OpCode, FwOpcode->QuestionId, &UOpcode.Question.QuestionId);
 701     if (EFI_ERROR (Status)) {
 702       //
 703       // Add a new opcode and it will not trigger call back. So we just reuse the FW QuestionId.
 704       //
 705       UOpcode.Question.QuestionId = AssignQuestionId (FwOpcode->QuestionId, ThunkContext->FormSet);
 706     }
 707   } else {
 708     UOpcode.Question.QuestionId    = FwOpcode->Key;
 709   }
 710
 711   UOpcode.Question.VarStoreId    = FRAMEWORK_RESERVED_VARSTORE_ID;
 712   UOpcode.Question.VarStoreInfo.VarOffset = FwOpcode->QuestionId;
 713
 714   //
 715   // We only  map 2 flags:
 716   //      FRAMEWORK_EFI_IFR_FLAG_INTERACTIVE,
 717   //      FRAMEWORK_EFI_IFR_FLAG_RESET_REQUIRED,
 718   // to UEFI IFR Opcode Question flags. The rest flags are obsolete.
 719   //
 720   UOpcode.Question.Flags  = (UINT8) (FwOpcode->Flags & (FRAMEWORK_EFI_IFR_FLAG_INTERACTIVE | FRAMEWORK_EFI_IFR_FLAG_RESET_REQUIRED));
 721
 722   //
 723   // We also map 2 flags:
 724   //      FRAMEWORK_EFI_IFR_FLAG_DEFAULT,
 725   //      FRAMEWORK_EFI_IFR_FLAG_MANUFACTURING,
 726   // to UEFI IFR CheckBox Opcode default flags.
 727   //
 728   UOpcode.Flags           = (UINT8) (FwOpcode->Flags & (FRAMEWORK_EFI_IFR_FLAG_DEFAULT | FRAMEWORK_EFI_IFR_FLAG_MANUFACTURING));
 729
 730   return AppendToUpdateBuffer ((UINT8 *) &UOpcode, sizeof(UOpcode), UefiData);
 731 }
 732
 733
 734 /*
 735 typedef struct _EFI_IFR_QUESTION_HEADER {
 736   EFI_IFR_STATEMENT_HEADER Header;
 737   EFI_QUESTION_ID          QuestionId;
 738   EFI_VARSTORE_ID          VarStoreId;
 739   union {
 740     EFI_STRING_ID          VarName;
 741     UINT16                 VarOffset;
 742   }                        VarStoreInfo;
 743   UINT8                    Flags;
 744 } EFI_IFR_QUESTION_HEADER;
 745
 746 typedef union {
 747   struct {
 748     UINT8 MinValue;
 749     UINT8 MaxValue;
 750     UINT8 Step;
 751   } u8;
 752   struct {
 753     UINT16 MinValue;
 754     UINT16 MaxValue;
 755     UINT16 Step;
 756   } u16;
 757   struct {
 758     UINT32 MinValue;
 759     UINT32 MaxValue;
 760     UINT32 Step;
 761   } u32;
 762   struct {
 763     UINT64 MinValue;
 764     UINT64 MaxValue;
 765     UINT64 Step;
 766   } u64;
 767 } MINMAXSTEP_DATA;
 768
 769 typedef struct _EFI_IFR_NUMERIC {
 770   EFI_IFR_OP_HEADER        Header;
 771   EFI_IFR_QUESTION_HEADER  Question;
 772   UINT8                    Flags;
 773   MINMAXSTEP_DATA          data;
 774 } EFI_IFR_NUMERIC;
 775
 776
 777 typedef struct {
 778   FRAMEWORK_EFI_IFR_OP_HEADER Header;
 779   UINT16            QuestionId; // The ID designating what the question is about...sucked in from a #define, likely in the form of a variable name
 780   UINT8             Width;      // The Size of the Data being saved
 781   STRING_REF        Prompt;     // The String Token for the Prompt
 782   STRING_REF        Help;       // The string Token for the context-help
 783   UINT8             Flags;      // This is included solely for purposes of interactive/dynamic support.
 784   UINT16            Key;        // Value to be passed to caller to identify this particular op-code
 785   UINT16            Minimum;
 786   UINT16            Maximum;
 787   UINT16            Step;       // If step is 0, then manual input is specified, otherwise, left/right arrow selection is called for
 788   UINT16            Default;
 789 } FRAMEWORK_EFI_IFR_NUMERIC;
 790
 791 */
 792
 793
 794 EFI_STATUS
 795 F2UCreateNumericOpCode (
 796   IN       HII_THUNK_CONTEXT           *ThunkContext,
 797   IN       UINT16                      VarStoreId,
 798   IN CONST FRAMEWORK_EFI_IFR_NUMERIC   *FwOpcode,
 799   OUT      EFI_HII_UPDATE_DATA         *UefiData
 800   )
 801 {
 802   EFI_STATUS      Status;
 803   EFI_IFR_NUMERIC UOpcode;
 804   EFI_IFR_DEFAULT UOpcodeDefault;
 805
 806   ZeroMem (&UOpcode, sizeof(UOpcode));
 807
 808   if (FwOpcode->Key == 0) {
 809     Status = FwQIdToUefiQId (ThunkContext->FormSet, VarStoreId, FwOpcode->Header.OpCode, FwOpcode->QuestionId, &UOpcode.Question.QuestionId);
 810     if (EFI_ERROR (Status)) {
 811       //
 812       // Add a new opcode and it will not trigger call back. So we just reuse the FW QuestionId.
 813       //
 814       UOpcode.Question.QuestionId = AssignQuestionId (FwOpcode->QuestionId, ThunkContext->FormSet);
 815     }
 816   } else {
 817     UOpcode.Question.QuestionId    = FwOpcode->Key;
 818   }
 819
 820   UOpcode.Header.Length = sizeof(UOpcode);
 821   UOpcode.Header.OpCode = EFI_IFR_NUMERIC_OP;
 822   //
 823   // We need to create a nested default value for the UEFI Numeric Opcode.
 824   // So turn on the scope.
 825   //
 826   UOpcode.Header.Scope = 1;
 827
 828   UOpcode.Question.Header.Prompt = FwOpcode->Prompt;
 829   UOpcode.Question.Header.Help = FwOpcode->Help;
 830
 831   UOpcode.Question.VarStoreId    = VarStoreId;
 832   UOpcode.Question.VarStoreInfo.VarOffset = FwOpcode->QuestionId;
 833
 834   UOpcode.Question.Flags  = (UINT8) (FwOpcode->Flags & (FRAMEWORK_EFI_IFR_FLAG_INTERACTIVE | FRAMEWORK_EFI_IFR_FLAG_RESET_REQUIRED));
 835
 836   //
 837   // Framework Numeric values are all in UINT16 and displayed as decimal.
 838   //
 839   UOpcode.data.u16.MinValue = FwOpcode->Minimum;
 840   UOpcode.data.u16.MaxValue = FwOpcode->Maximum;
 841   UOpcode.data.u16.Step = FwOpcode->Step;
 842
 843   switch (FwOpcode->Width) {
 844     case 1:
 845     {
 846       UOpcode.Flags           =  EFI_IFR_NUMERIC_SIZE_1 | EFI_IFR_DISPLAY_UINT_DEC;
 847       break;
 848     }
 849     case 2:
 850     {
 851       UOpcode.Flags           =  EFI_IFR_NUMERIC_SIZE_2 | EFI_IFR_DISPLAY_UINT_DEC;
 852       break;
 853     }
 854     default:
 855     {
 856       ASSERT (FALSE);
 857       return EFI_INVALID_PARAMETER;
 858     }
 859   }
 860
 861   Status = AppendToUpdateBuffer ((UINT8 *) &UOpcode, sizeof(UOpcode), UefiData);
 862   if (EFI_ERROR (Status)) {
 863     return Status;
 864   }
 865
 866   //
 867   // We need to create a default value.
 868   //
 869   ZeroMem (&UOpcodeDefault, sizeof (UOpcodeDefault));
 870   UOpcodeDefault.Header.Length = sizeof (UOpcodeDefault);
 871   UOpcodeDefault.Header.OpCode = EFI_IFR_DEFAULT_OP;
 872
 873   UOpcodeDefault.DefaultId = 0;
 874
 875   switch (FwOpcode->Width) {
 876     case 1:
 877     {
 878       UOpcodeDefault.Type = EFI_IFR_TYPE_NUM_SIZE_8;
 879       break;
 880     }
 881     case 2:
 882     {
 883       UOpcodeDefault.Type = EFI_IFR_TYPE_NUM_SIZE_16;
 884       break;
 885     }
 886   }
 887
 888   CopyMem (&UOpcodeDefault.Value.u8, &FwOpcode->Default, FwOpcode->Width);
 889
 890   Status = AppendToUpdateBuffer ((UINT8 *) &UOpcodeDefault, sizeof(UOpcodeDefault), UefiData);
 891   if (EFI_ERROR (Status)) {
 892     return Status;
 893   }
 894   Status = UCreateEndOfOpcode (UefiData);
 895
 896   return Status;
 897 }
 898
 899
 900 /*
 901
 902 typedef struct _EFI_IFR_QUESTION_HEADER {
 903   EFI_IFR_STATEMENT_HEADER Header;
 904   EFI_QUESTION_ID          QuestionId;
 905   EFI_VARSTORE_ID          VarStoreId;
 906   union {
 907     EFI_STRING_ID          VarName;
 908     UINT16                 VarOffset;
 909   }                        VarStoreInfo;
 910   UINT8                    Flags;
 911 } EFI_IFR_QUESTION_HEADER;
 912
 913 typedef struct _EFI_IFR_STRING {
 914   EFI_IFR_OP_HEADER        Header;
 915   EFI_IFR_QUESTION_HEADER  Question;
 916   UINT8                    MinSize;
 917   UINT8                    MaxSize;
 918   UINT8                    Flags;
 919 } EFI_IFR_STRING;
 920
 921
 922 typedef struct {
 923   FRAMEWORK_EFI_IFR_OP_HEADER Header;
 924   UINT16            QuestionId;   // The ID designating what the question is about...sucked in from a #define, likely in the form of a variable name
 925   UINT8             Width;        // The Size of the Data being saved -- BUGBUG -- remove someday
 926   STRING_REF        Prompt;       // The String Token for the Prompt
 927   STRING_REF        Help;         // The string Token for the context-help
 928   UINT8             Flags;        // This is included solely for purposes of interactive/dynamic support.
 929   UINT16            Key;          // Value to be passed to caller to identify this particular op-code
 930   UINT8             MinSize;      // Minimum allowable sized password
 931   UINT8             MaxSize;      // Maximum allowable sized password
 932 } FRAMEWORK_EFI_IFR_STRING;
 933
 934
 935 */
 936
 937 EFI_STATUS
 938 F2UCreateStringOpCode (
 939   IN       HII_THUNK_CONTEXT               *ThunkContext,
 940   IN       UINT16                      VarStoreId,
 941   IN CONST FRAMEWORK_EFI_IFR_STRING    *FwOpcode,
 942   OUT      EFI_HII_UPDATE_DATA         *UefiData
 943   )
 944 {
 945   EFI_IFR_STRING UOpcode;
 946
 947   ZeroMem (&UOpcode, sizeof(UOpcode));
 948
 949   if (FwOpcode->Key == 0) {
 950     FwQIdToUefiQId (ThunkContext->FormSet, VarStoreId, FwOpcode->Header.OpCode, FwOpcode->QuestionId, &UOpcode.Question.QuestionId);
 951   } else {
 952     UOpcode.Question.QuestionId    = FwOpcode->Key;
 953   }
 954
 955   UOpcode.Header.Length = sizeof(UOpcode);
 956   UOpcode.Header.OpCode = EFI_IFR_STRING_OP;
 957
 958   UOpcode.Question.Header.Prompt = FwOpcode->Prompt;
 959   UOpcode.Question.Header.Help = FwOpcode->Help;
 960
 961   UOpcode.Question.QuestionId    = FwOpcode->Key;
 962   UOpcode.Question.VarStoreId    = FRAMEWORK_RESERVED_VARSTORE_ID;
 963   UOpcode.Question.VarStoreInfo.VarOffset = FwOpcode->QuestionId;
 964
 965   UOpcode.Question.Flags  = (UINT8) (FwOpcode->Flags & (FRAMEWORK_EFI_IFR_FLAG_INTERACTIVE | FRAMEWORK_EFI_IFR_FLAG_RESET_REQUIRED));
 966
 967   UOpcode.MinSize = FwOpcode->MinSize;
 968   UOpcode.MaxSize = FwOpcode->MaxSize;
 969   UOpcode.Flags   = EFI_IFR_STRING_MULTI_LINE;
 970
 971   return AppendToUpdateBuffer ((UINT8 *) &UOpcode, sizeof(UOpcode), UefiData);
 972 }
 973
 974 /*
 975 typedef struct _EFI_IFR_GUID_BANNER {
 976   EFI_IFR_OP_HEADER   Header;
 977   EFI_GUID            Guid;
 978   UINT8               ExtendOpCode; // Extended opcode is EFI_IFR_EXTEND_OP_BANNER
 979   EFI_STRING_ID       Title;        // The string token for the banner title
 980   UINT16              LineNumber;   // 1-based line number
 981   UINT8               Alignment;    // left, center, or right-aligned
 982 } EFI_IFR_GUID_BANNER;
 983
 984 typedef struct {
 985   FRAMEWORK_EFI_IFR_OP_HEADER Header;
 986   STRING_REF        Title;        // The string token for the banner title
 987   UINT16            LineNumber;   // 1-based line number
 988   UINT8             Alignment;    // left, center, or right-aligned
 989 } FRAMEWORK_EFI_IFR_BANNER;
 990
 991 */
 992
 993 EFI_STATUS
 994 F2UCreateBannerOpCode (
 995   IN CONST FRAMEWORK_EFI_IFR_BANNER    *FwOpcode,
 996   OUT      EFI_HII_UPDATE_DATA         *UefiData
 997   )
 998 {
 999   EFI_IFR_GUID_BANNER UOpcode;
1000
1001   ZeroMem (&UOpcode, sizeof(UOpcode));
1002
1003   UOpcode.Header.Length = sizeof(UOpcode);
1004   UOpcode.Header.OpCode = EFI_IFR_GUID_OP;
1005
1006   CopyMem (&UOpcode.Guid, &mTianoExtendedOpcodeGuid, sizeof (EFI_GUID));
1007   UOpcode.ExtendOpCode = EFI_IFR_EXTEND_OP_BANNER;
1008   UOpcode.Title          = FwOpcode->Title;
1009   UOpcode.LineNumber     = FwOpcode->LineNumber;
1010   UOpcode.Alignment      = FwOpcode->Alignment;
1011
1012   return AppendToUpdateBuffer ((UINT8 *) &UOpcode, sizeof(UOpcode), UefiData);
1013 }
1014
1015
1016 EFI_STATUS
1017 FwUpdateDataToUefiUpdateData (
1018   IN       HII_THUNK_CONTEXT                 *ThunkContext,
1019   IN CONST FRAMEWORK_EFI_HII_UPDATE_DATA    *Data,
1020   OUT      EFI_HII_UPDATE_DATA              **UefiData
1021   )
1022 {
1023   FRAMEWORK_EFI_IFR_OP_HEADER          *FwOpCode;
1024   FRAMEWORK_EFI_IFR_OP_HEADER          *NextFwOpCode;
1025   EFI_HII_UPDATE_DATA                  *UefiOpCode;
1026   UINTN                                Index;
1027   EFI_STATUS                           Status;
1028   UINTN                                DataCount;
1029   UINT16                               VarStoreId;
1030
1031   //
1032   // Assume all dynamic opcode created is using active variable with VarStoreId of 1.
1033   //
1034   VarStoreId = 1;
1035
1036   UefiOpCode = AllocateZeroPool (sizeof (EFI_HII_UPDATE_DATA));
1037   if (UefiOpCode == NULL) {
1038     return EFI_OUT_OF_RESOURCES;
1039   }
1040
1041   UefiOpCode->Data = AllocateZeroPool (LOCAL_UPDATE_DATA_BUFFER_INCREMENTAL);
1042   if (UefiOpCode->Data == NULL) {
1043     return EFI_OUT_OF_RESOURCES;
1044   }
1045
1046   UefiOpCode->BufferSize = LOCAL_UPDATE_DATA_BUFFER_INCREMENTAL;
1047   UefiOpCode->Offset = 0;
1048
1049   FwOpCode = (FRAMEWORK_EFI_IFR_OP_HEADER *) &Data->Data;
1050
1051   for (Index = 0; Index < Data->DataCount; Index += DataCount) {
1052     switch (FwOpCode->OpCode) {
1053       case FRAMEWORK_EFI_IFR_SUBTITLE_OP:
1054         Status = F2UCreateSubtitleOpCode ((FRAMEWORK_EFI_IFR_SUBTITLE  *) FwOpCode, UefiOpCode);
1055         DataCount = 1;
1056         break;
1057
1058       case FRAMEWORK_EFI_IFR_TEXT_OP:
1059         Status = F2UCreateTextOpCode ((FRAMEWORK_EFI_IFR_TEXT  *) FwOpCode, UefiOpCode);
1060         DataCount = 1;
1061         break;
1062
1063       case FRAMEWORK_EFI_IFR_REF_OP:
1064         Status = F2UCreateGotoOpCode ((FRAMEWORK_EFI_IFR_REF *) FwOpCode, UefiOpCode);
1065         DataCount = 1;
1066         break;
1067
1068       case FRAMEWORK_EFI_IFR_ONE_OF_OP:
1069         Status = F2UCreateOneOfOpCode (ThunkContext, VarStoreId, (FRAMEWORK_EFI_IFR_ONE_OF *) FwOpCode, UefiOpCode, &NextFwOpCode, &DataCount);
1070         if (!EFI_ERROR (Status)) {
1071           FwOpCode = NextFwOpCode;
1072           //
1073           // FwOpCode is already updated to point to the next opcode.
1074           //
1075           continue;
1076         }
1077         break;
1078
1079       case FRAMEWORK_EFI_IFR_ORDERED_LIST_OP:
1080         Status = F2UCreateOrderedListOpCode (ThunkContext, VarStoreId, (FRAMEWORK_EFI_IFR_ORDERED_LIST *) FwOpCode, UefiOpCode, &NextFwOpCode, &DataCount);
1081         if (!EFI_ERROR (Status)) {
1082           FwOpCode = NextFwOpCode;
1083           //
1084           // FwOpCode is already updated to point to the next opcode.
1085           //
1086           continue;
1087         }
1088         break;
1089
1090       case FRAMEWORK_EFI_IFR_CHECKBOX_OP:
1091         Status = F2UCreateCheckBoxOpCode (ThunkContext, VarStoreId, (FRAMEWORK_EFI_IFR_CHECKBOX *) FwOpCode, UefiOpCode);
1092         DataCount = 1;
1093         break;
1094
1095       case FRAMEWORK_EFI_IFR_STRING_OP:
1096         Status = F2UCreateStringOpCode (ThunkContext, VarStoreId, (FRAMEWORK_EFI_IFR_STRING *) FwOpCode, UefiOpCode);
1097         DataCount = 1;
1098         break;
1099
1100       case FRAMEWORK_EFI_IFR_BANNER_OP:
1101         Status = F2UCreateBannerOpCode ((FRAMEWORK_EFI_IFR_BANNER *) FwOpCode, UefiOpCode);
1102         DataCount = 1;
1103         break;
1104
1105       case FRAMEWORK_EFI_IFR_END_ONE_OF_OP:
1106         Status = UCreateEndOfOpcode (UefiOpCode);
1107         DataCount = 1;
1108         break;
1109
1110       case FRAMEWORK_EFI_IFR_NUMERIC_OP:
1111         Status = F2UCreateNumericOpCode (ThunkContext, VarStoreId, (FRAMEWORK_EFI_IFR_NUMERIC *) FwOpCode, UefiOpCode);
1112         DataCount = 1;
1113         break;
1114
1115       default:
1116         ASSERT (FALSE);
1117         return EFI_UNSUPPORTED;
1118     }
1119
1120     if (EFI_ERROR (Status)) {
1121       FreePool (UefiOpCode->Data);
1122       FreePool (UefiOpCode);
1123       return Status;
1124     }
1125
1126     FwOpCode = (FRAMEWORK_EFI_IFR_OP_HEADER *)((UINT8 *) FwOpCode + FwOpCode->Length);
1127   }
1128
1129   *UefiData = UefiOpCode;
1130
1131   return EFI_SUCCESS;
1132 }
1133