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