EdkCompatibilityPkg/Compatibility/FrameworkHiiToUefiHiiThunk/Utility.c

   1 /**@file
   2
   3   This file contains the keyboard processing code to the HII database.
   4
   5 Copyright (c) 2006 - 2008, 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
  16
  17 #include "HiiDatabase.h"
  18 #include "HiiHandle.h"
  19
  20 EFI_GUID  gFrameworkHiiCompatbilityGuid = EFI_IFR_FRAMEWORK_GUID;
  21 EFI_GUID  gTianoHiiIfrGuid              = EFI_IFR_TIANO_GUID;
  22
  23
  24 EFI_HII_HANDLE
  25 FwHiiHandleToUefiHiiHandle (
  26   IN CONST HII_THUNK_PRIVATE_DATA      *Private,
  27   IN FRAMEWORK_EFI_HII_HANDLE          FwHiiHandle
  28   )
  29 {
  30   HII_THUNK_CONTEXT            *ThunkContext;
  31
  32   ASSERT (FwHiiHandle != (FRAMEWORK_EFI_HII_HANDLE) 0);
  33   ASSERT (Private != NULL);
  34
  35   ThunkContext = FwHiiHandleToThunkContext (Private, FwHiiHandle);
  36
  37   if (ThunkContext != NULL) {
  38     return ThunkContext->UefiHiiHandle;
  39   }
  40
  41   return (EFI_HII_HANDLE) NULL;
  42 }
  43
  44
  45 HII_THUNK_CONTEXT *
  46 FwHiiHandleToThunkContext (
  47   IN CONST HII_THUNK_PRIVATE_DATA      *Private,
  48   IN FRAMEWORK_EFI_HII_HANDLE          FwHiiHandle
  49   )
  50 {
  51   LIST_ENTRY                 *Link;
  52   HII_THUNK_CONTEXT           *ThunkContext;
  53
  54
  55   Link = GetFirstNode (&Private->ThunkContextListHead);
  56
  57   while (!IsNull (&Private->ThunkContextListHead, Link)) {
  58     ThunkContext = HII_THUNK_CONTEXT_FROM_LINK (Link);
  59
  60     if (FwHiiHandle == ThunkContext->FwHiiHandle) {
  61       return ThunkContext;
  62     }
  63
  64     Link = GetNextNode (&Private->ThunkContextListHead, Link);
  65   }
  66
  67   return NULL;
  68 }
  69
  70 HII_THUNK_CONTEXT *
  71 UefiHiiHandleToThunkContext (
  72   IN CONST HII_THUNK_PRIVATE_DATA     *Private,
  73   IN EFI_HII_HANDLE                   UefiHiiHandle
  74   )
  75 {
  76   LIST_ENTRY                 *Link;
  77   HII_THUNK_CONTEXT           *ThunkContext;
  78
  79   Link = GetFirstNode (&Private->ThunkContextListHead);
  80
  81   while (!IsNull (&Private->ThunkContextListHead, Link)) {
  82     ThunkContext = HII_THUNK_CONTEXT_FROM_LINK (Link);
  83
  84     if (UefiHiiHandle == ThunkContext->UefiHiiHandle) {
  85       return ThunkContext;
  86     }
  87     Link = GetNextNode (&Private->ThunkContextListHead, Link);
  88   }
  89
  90   return NULL;
  91 }
  92
  93 HII_THUNK_CONTEXT *
  94 TagGuidToIfrPackThunkContext (
  95   IN CONST HII_THUNK_PRIVATE_DATA *Private,
  96   IN CONST EFI_GUID                   *Guid
  97   )
  98 {
  99   LIST_ENTRY                 *Link;
 100   HII_THUNK_CONTEXT           *ThunkContext;
 101
 102   Link = GetFirstNode (&Private->ThunkContextListHead);
 103
 104   while (!IsNull (&Private->ThunkContextListHead, Link)) {
 105     ThunkContext = HII_THUNK_CONTEXT_FROM_LINK (Link);
 106
 107     if (CompareGuid (Guid, &ThunkContext->TagGuid) && (ThunkContext->IfrPackageCount != 0)) {
 108       return ThunkContext;
 109     }
 110
 111     Link = GetNextNode (&Private->ThunkContextListHead, Link);
 112   }
 113
 114   return NULL;
 115
 116 }
 117
 118
 119 VOID
 120 DestroyThunkContextForUefiHiiHandle (
 121   IN HII_THUNK_PRIVATE_DATA     *Private,
 122   IN EFI_HII_HANDLE             UefiHiiHandle
 123  )
 124 {
 125   HII_THUNK_CONTEXT     *ThunkContext;
 126
 127   ThunkContext = UefiHiiHandleToThunkContext (Private, UefiHiiHandle);
 128   ASSERT (ThunkContext != NULL);
 129
 130   DestroyThunkContext (ThunkContext);
 131 }
 132
 133
 134 /**
 135   This function create a HII_THUNK_CONTEXT for a package list registered
 136   by a module calling EFI_HII_DATABASE_PROTOCOL.NewPackageList. It records
 137   the PackageListGuid in EFI_HII_PACKAGE_LIST_HEADER in the TagGuid in
 138   HII_THUNK_CONTEXT created. This TagGuid will be used as a key to s
 139
 140 **/
 141 HII_THUNK_CONTEXT *
 142 CreateThunkContextForUefiHiiHandle (
 143   IN  EFI_HII_HANDLE             UefiHiiHandle
 144  )
 145 {
 146   EFI_STATUS            Status;
 147   EFI_GUID              PackageGuid;
 148   HII_THUNK_CONTEXT      *ThunkContext;
 149
 150   ThunkContext = AllocateZeroPool (sizeof (*ThunkContext));
 151   ASSERT (ThunkContext != NULL);
 152
 153   ThunkContext->Signature = HII_THUNK_CONTEXT_SIGNATURE;
 154
 155   Status = AllocateHiiHandle (&ThunkContext->FwHiiHandle);
 156   if (EFI_ERROR (Status)) {
 157     return NULL;
 158   }
 159
 160   ThunkContext->UefiHiiHandle = UefiHiiHandle;
 161
 162   Status = HiiLibExtractGuidFromHiiHandle (UefiHiiHandle, &PackageGuid);
 163   ASSERT_EFI_ERROR (Status);
 164
 165   CopyGuid(&ThunkContext->TagGuid, &PackageGuid);
 166
 167   InitializeListHead (&ThunkContext->QuestionIdMapListHead);
 168   InitializeListHead (&ThunkContext->OneOfOptionMapListHead);
 169
 170   return ThunkContext;
 171 }
 172
 173
 174 UINTN
 175 GetPackageCountByType (
 176   IN CONST EFI_HII_PACKAGE_LIST_HEADER     *PackageListHeader,
 177   IN       UINT8                           PackageType
 178   )
 179 {
 180   UINTN                     Count;
 181   EFI_HII_PACKAGE_HEADER    *PackageHeader;
 182
 183   PackageHeader = (EFI_HII_PACKAGE_HEADER *) ((UINT8 *) PackageListHeader + sizeof (EFI_HII_PACKAGE_LIST_HEADER));
 184   Count = 0;
 185
 186   while (PackageHeader->Type != EFI_HII_PACKAGE_END) {
 187     if (PackageHeader->Type == PackageType ) {
 188       Count++;
 189     }
 190     PackageHeader = (EFI_HII_PACKAGE_HEADER *) ((UINT8 *) PackageHeader + PackageHeader->Length);
 191   }
 192
 193
 194   return Count;
 195 }
 196
 197 LIST_ENTRY *
 198 GetOneOfOptionMapEntryListHead (
 199   IN CONST HII_THUNK_CONTEXT  *ThunkContext,
 200   IN       UINT16             QuestionId
 201   )
 202 {
 203   LIST_ENTRY            *Link;
 204   ONE_OF_OPTION_MAP     *Map;
 205
 206   Link = GetFirstNode (&ThunkContext->OneOfOptionMapListHead);
 207
 208   while (!IsNull (&ThunkContext->OneOfOptionMapListHead, Link)) {
 209     Map = ONE_OF_OPTION_MAP_FROM_LINK (Link);
 210     if (QuestionId == Map->QuestionId) {
 211       return &Map->OneOfOptionMapEntryListHead;
 212     }
 213     Link = GetNextNode (&ThunkContext->OneOfOptionMapListHead, Link);
 214   }
 215
 216   return NULL;
 217 }
 218
 219 EFI_HII_PACKAGE_HEADER *
 220 GetIfrPackage (
 221   IN CONST EFI_HII_PACKAGES               *Packages
 222   )
 223 {
 224   UINTN                         Index;
 225   TIANO_AUTOGEN_PACKAGES_HEADER **TianoAutogenPackageHdrArray;
 226
 227   ASSERT (Packages != NULL);
 228
 229   TianoAutogenPackageHdrArray = (TIANO_AUTOGEN_PACKAGES_HEADER **) (((UINT8 *) &Packages->GuidId) + sizeof (Packages->GuidId));
 230
 231   for (Index = 0; Index < Packages->NumberOfPackages; Index++) {
 232     //
 233     // The current UEFI HII build tool generate a binary in the format defined by
 234     // TIANO_AUTOGEN_PACKAGES_HEADER. We assume that all packages generated in
 235     // this binary is with same package type. So the returned IfrPackageCount and StringPackageCount
 236     // may not be the exact number of valid package number in the binary generated
 237     // by HII Build tool.
 238     //
 239     switch (TianoAutogenPackageHdrArray[Index]->PackageHeader.Type) {
 240       case EFI_HII_PACKAGE_FORM:
 241         return &TianoAutogenPackageHdrArray[Index]->PackageHeader;
 242         break;
 243       case EFI_HII_PACKAGE_STRINGS:
 244       case EFI_HII_PACKAGE_SIMPLE_FONTS:
 245         break;
 246
 247       //
 248       // The following fonts are invalid for a module that using Framework to UEFI thunk layer.
 249       //
 250       case EFI_HII_PACKAGE_KEYBOARD_LAYOUT:
 251       case EFI_HII_PACKAGE_FONTS:
 252       case EFI_HII_PACKAGE_IMAGES:
 253       default:
 254         ASSERT (FALSE);
 255         return NULL;
 256         break;
 257     }
 258   }
 259
 260   return NULL;
 261 }
 262
 263 VOID
 264 GetFormSetGuid (
 265   IN  EFI_HII_PACKAGE_HEADER  *Package,
 266   OUT EFI_GUID                *FormSetGuid
 267   )
 268 {
 269   UINTN                         Offset;
 270   EFI_IFR_OP_HEADER             *OpCode;
 271   EFI_IFR_FORM_SET              *FormSet;
 272
 273   Offset = sizeof (EFI_HII_PACKAGE_HEADER);
 274   while (Offset < Package->Length) {
 275     OpCode = (EFI_IFR_OP_HEADER *)((UINT8 *) Package + Offset);
 276
 277     switch (OpCode->OpCode) {
 278     case EFI_IFR_FORM_SET_OP:
 279       FormSet = (EFI_IFR_FORM_SET *) OpCode;
 280       CopyMem (FormSetGuid, &FormSet->Guid, sizeof (EFI_GUID));
 281       return;
 282
 283       default:
 284         break;
 285
 286     }
 287     Offset += OpCode->Length;
 288   }
 289
 290   //
 291   // A proper IFR must have a formset opcode.
 292   //
 293   ASSERT (FALSE);
 294
 295 }
 296
 297
 298 VOID
 299 GetAttributesOfFirstFormSet (
 300   IN    OUT HII_THUNK_CONTEXT  *ThunkContext
 301   )
 302 {
 303   EFI_STATUS                    Status;
 304   EFI_HII_PACKAGE_LIST_HEADER   *List;
 305   EFI_HII_PACKAGE_HEADER        *Package;
 306   UINTN                         Size;
 307   EFI_IFR_OP_HEADER             *OpCode;
 308   UINTN                         Offset;
 309   EFI_IFR_GUID_CLASS            *Class;
 310   EFI_IFR_FORM_SET              *FormSet;
 311   EFI_IFR_GUID_SUBCLASS         *SubClass;
 312
 313   Status = HiiLibExportPackageLists (ThunkContext->UefiHiiHandle, &List, &Size);
 314   ASSERT_EFI_ERROR (Status);
 315
 316   //
 317   // There must be at least one EFI_HII_PACKAGE_FORM in the package list.
 318   //
 319   ASSERT (GetPackageCountByType (List, EFI_HII_PACKAGE_FORM) >= 1);
 320
 321   //
 322   // Skip the package list header.
 323   //
 324   Package = (EFI_HII_PACKAGE_HEADER *) (List + 1);
 325
 326   while (Package->Type != EFI_HII_PACKAGE_END) {
 327
 328     if (Package->Type == EFI_HII_PACKAGE_FORM) {
 329
 330       //
 331       // Skip the package header
 332       //
 333       Offset = sizeof (EFI_HII_PACKAGE_HEADER);
 334       while (Offset < Package->Length) {
 335         OpCode = (EFI_IFR_OP_HEADER *)((UINT8 *) Package + Offset);
 336
 337         switch (OpCode->OpCode) {
 338         case EFI_IFR_FORM_SET_OP:
 339           FormSet = (EFI_IFR_FORM_SET *) OpCode;
 340           ThunkContext->FormSetTitle = FormSet->FormSetTitle;
 341           ThunkContext->FormSetHelp  = FormSet->Help;
 342           break;
 343
 344
 345         case EFI_IFR_GUID_OP:
 346           Class = (EFI_IFR_GUID_CLASS*) OpCode;
 347           if (CompareMem (&Class->Guid, &gTianoHiiIfrGuid, sizeof (EFI_GUID)) == 0) {
 348             Class = (EFI_IFR_GUID_CLASS *) OpCode;
 349
 350             switch (Class->ExtendOpCode) {
 351               case EFI_IFR_EXTEND_OP_CLASS:
 352                 ThunkContext->FormSetClass = Class->Class;
 353                 break;
 354               case EFI_IFR_EXTEND_OP_SUBCLASS:
 355                 SubClass = (EFI_IFR_GUID_SUBCLASS *) OpCode;
 356                 ThunkContext->FormSetSubClass = SubClass->SubClass;
 357                 break;
 358
 359               default:
 360                 break;
 361             }
 362           }
 363           break;
 364
 365         default:
 366           break;
 367
 368         }
 369
 370         Offset += OpCode->Length;
 371       }
 372       //
 373       // The attributes of first FormSet is ready now.
 374       //
 375       FreePool (List);
 376       return;
 377
 378       break;
 379     }
 380
 381     Package = (EFI_HII_PACKAGE_HEADER *) ((UINT8 *) Package + Package->Length);
 382   }
 383
 384 }
 385
 386
 387 EFI_STATUS
 388 CreateQuestionIdMap (
 389   IN    OUT HII_THUNK_CONTEXT  *ThunkContext
 390   )
 391 {
 392   EFI_STATUS                    Status;
 393   EFI_HII_PACKAGE_LIST_HEADER   *List;
 394   EFI_HII_PACKAGE_HEADER        *Package;
 395   UINTN                         Size;
 396   EFI_IFR_OP_HEADER             *OpCode;
 397   UINTN                         Offset;
 398   QUESTION_ID_MAP               *IdMap;
 399   EFI_IFR_VARSTORE              *VarStore;
 400   EFI_IFR_FORM_SET              *FormSet;
 401   EFI_IFR_QUESTION_HEADER       *Question;
 402   LIST_ENTRY                    *QuestionIdMapEntryListHead;
 403   LIST_ENTRY                    *OneOfOptinMapEntryListHead;
 404   QUESTION_ID_MAP_ENTRY         *IdMapEntry;
 405   EFI_IFR_GUID_OPTIONKEY        *OptionMap;
 406   ONE_OF_OPTION_MAP             *OneOfOptionMap;
 407   ONE_OF_OPTION_MAP_ENTRY       *OneOfOptionMapEntry;
 408   EFI_IFR_GUID_CLASS            *Class;
 409   EFI_IFR_GUID_SUBCLASS         *SubClass;
 410   UINT8                         OneOfType;
 411   EFI_IFR_ONE_OF                *OneOfOpcode;
 412
 413   //
 414   // Set to a invalid value.
 415   //
 416   OneOfType = (UINT8) -1;
 417
 418
 419   Status = HiiLibExportPackageLists (ThunkContext->UefiHiiHandle, &List, &Size);
 420   if (EFI_ERROR (Status)) {
 421     return Status;
 422   }
 423
 424   //
 425   // Get all VarStoreId and build the the QuestionId map.
 426   // EFI_IFR_QUESTION_HEADER.VarStoreInfo.VarOffset -> Framework Question ID
 427   // EFI_IFR_QUESTION_HEADER.QuestionId             -> UEFI Question ID
 428   //
 429
 430   //
 431   // Skip the package list header.
 432   //
 433   Package = (EFI_HII_PACKAGE_HEADER *) (List + 1);
 434
 435   while (Package->Type != EFI_HII_PACKAGE_END) {
 436
 437     if (Package->Type == EFI_HII_PACKAGE_FORM) {
 438
 439       //
 440       // Skip the package header
 441       //
 442       Offset = sizeof (EFI_HII_PACKAGE_HEADER);
 443       while (Offset < Package->Length) {
 444         OpCode = (EFI_IFR_OP_HEADER *)((UINT8 *) Package + Offset);
 445
 446         switch (OpCode->OpCode) {
 447         case EFI_IFR_FORM_SET_OP:
 448           FormSet = (EFI_IFR_FORM_SET *) OpCode;
 449           ThunkContext->FormSetTitle = FormSet->FormSetTitle;
 450           ThunkContext->FormSetHelp  = FormSet->Help;
 451           break;
 452
 453         case EFI_IFR_VARSTORE_OP:
 454           //
 455           // IFR built from Framework VFR only has UEFI Buffer Type Storage
 456           //
 457           VarStore = (EFI_IFR_VARSTORE *) OpCode;
 458           IdMap = AllocateZeroPool (sizeof (QUESTION_ID_MAP));
 459           ASSERT (IdMap != NULL);
 460
 461           IdMap->Signature  = QUESTION_ID_MAP_SIGNATURE;
 462           IdMap->VarStoreId = VarStore->VarStoreId;
 463           IdMap->VarSize    = VarStore->Size;
 464           InitializeListHead (&IdMap->MapEntryListHead);
 465           InsertTailList (&ThunkContext->QuestionIdMapListHead, &IdMap->Link);
 466           break;
 467
 468         case EFI_IFR_NUMERIC_OP:
 469         case EFI_IFR_CHECKBOX_OP:
 470         case EFI_IFR_ONE_OF_OP:
 471         case EFI_IFR_ORDERED_LIST_OP:
 472         case EFI_IFR_STRING_OP:
 473         //case EFI_IFR_PASSWORD_OP:
 474           Question = (EFI_IFR_QUESTION_HEADER *)(OpCode + 1);
 475           QuestionIdMapEntryListHead = GetMapEntryListHead (ThunkContext, Question->VarStoreId);
 476
 477           if (QuestionIdMapEntryListHead != NULL) {
 478             //
 479             // If the Question is using Buffer (EFI_IFR_VARSTORE_OP) type VarStore.
 480             //
 481             IdMapEntry = AllocateZeroPool (sizeof (QUESTION_ID_MAP_ENTRY));
 482             ASSERT (IdMapEntry != NULL);
 483
 484             IdMapEntry->FwQId = Question->VarStoreInfo.VarOffset;
 485             IdMapEntry->UefiQid = Question->QuestionId;
 486             IdMapEntry->Signature = QUESTION_ID_MAP_ENTRY_SIGNATURE;
 487
 488             InsertTailList (QuestionIdMapEntryListHead, &IdMapEntry->Link);
 489           }
 490
 491           if (OpCode->OpCode == EFI_IFR_ONE_OF_OP) {
 492             OneOfOpcode = (EFI_IFR_ONE_OF *) OpCode;
 493             OneOfType   = OneOfOpcode->Flags & EFI_IFR_NUMERIC_SIZE;
 494           }
 495
 496           break;
 497
 498         case EFI_IFR_GUID_OP:
 499           OptionMap = (EFI_IFR_GUID_OPTIONKEY *) OpCode;
 500           if (CompareMem (&OptionMap->Guid, &gFrameworkHiiCompatbilityGuid, sizeof (EFI_GUID)) == 0) {
 501             if (OptionMap->ExtendOpCode == EFI_IFR_EXTEND_OP_OPTIONKEY) {
 502               OneOfOptinMapEntryListHead = GetOneOfOptionMapEntryListHead (ThunkContext, OptionMap->QuestionId);
 503               if (OneOfOptinMapEntryListHead == NULL) {
 504                 OneOfOptionMap = AllocateZeroPool (sizeof (ONE_OF_OPTION_MAP));
 505                 ASSERT (OneOfOptionMap != NULL);
 506
 507                 OneOfOptionMap->Signature = ONE_OF_OPTION_MAP_SIGNATURE;
 508                 OneOfOptionMap->QuestionId = OptionMap->QuestionId;
 509
 510                 //
 511                 // Make sure OneOfType is initialized.
 512                 //
 513                 ASSERT (OneOfType != (UINT8) -1);
 514                 OneOfOptionMap->ValueType = OneOfType;
 515                 InitializeListHead (&OneOfOptionMap->OneOfOptionMapEntryListHead);
 516                 OneOfOptinMapEntryListHead = &OneOfOptionMap->OneOfOptionMapEntryListHead;
 517                 InsertTailList (&ThunkContext->OneOfOptionMapListHead, &OneOfOptionMap->Link);
 518               }
 519               OneOfOptionMapEntry = AllocateZeroPool (sizeof (ONE_OF_OPTION_MAP_ENTRY));
 520               ASSERT (OneOfOptionMapEntry != NULL);
 521
 522               OneOfOptionMapEntry->Signature = ONE_OF_OPTION_MAP_ENTRY_SIGNATURE;
 523               OneOfOptionMapEntry->FwKey = OptionMap->KeyValue;
 524               CopyMem (&OneOfOptionMapEntry->Value, &OptionMap->OptionValue, sizeof (EFI_IFR_TYPE_VALUE));
 525
 526               InsertTailList (OneOfOptinMapEntryListHead, &OneOfOptionMapEntry->Link);
 527             }
 528          } else if (CompareMem (&OptionMap->Guid, &gTianoHiiIfrGuid, sizeof (EFI_GUID)) == 0) {
 529             Class = (EFI_IFR_GUID_CLASS *) OpCode;
 530
 531             switch (Class->ExtendOpCode) {
 532               case EFI_IFR_EXTEND_OP_CLASS:
 533                 ThunkContext->FormSetClass = Class->Class;
 534                 break;
 535               case EFI_IFR_EXTEND_OP_SUBCLASS:
 536                 SubClass = (EFI_IFR_GUID_SUBCLASS *) OpCode;
 537                 ThunkContext->FormSetSubClass = SubClass->SubClass;
 538                 break;
 539
 540               default:
 541                 break;
 542             }
 543           }
 544           break;
 545
 546         default:
 547           break;
 548
 549         }
 550
 551         Offset += OpCode->Length;
 552       }
 553       //
 554       // Only Form Package is in a Package List.
 555       //
 556       break;
 557     }
 558
 559     Package = (EFI_HII_PACKAGE_HEADER *) (UINT8 *) Package + Package->Length;
 560   }
 561
 562   FreePool (List);
 563   return EFI_SUCCESS;
 564 }
 565
 566
 567 LIST_ENTRY *
 568 GetMapEntryListHead (
 569   IN CONST HII_THUNK_CONTEXT  *ThunkContext,
 570   IN       UINT16             VarStoreId
 571   )
 572 {
 573   LIST_ENTRY            *Link;
 574   QUESTION_ID_MAP       *Map;
 575
 576   Link = GetFirstNode (&ThunkContext->QuestionIdMapListHead);
 577
 578   while (!IsNull (&ThunkContext->QuestionIdMapListHead, Link)) {
 579     Map = QUESTION_ID_MAP_FROM_LINK (Link);
 580     if (VarStoreId == Map->VarStoreId) {
 581       return &Map->MapEntryListHead;
 582     }
 583     Link = GetNextNode (&ThunkContext->QuestionIdMapListHead, Link);
 584   }
 585   return NULL;
 586 }
 587
 588
 589 HII_THUNK_CONTEXT *
 590 CreateThunkContext (
 591   IN  HII_THUNK_PRIVATE_DATA      *Private,
 592   IN  UINTN                       StringPackageCount,
 593   IN  UINTN                       IfrPackageCount
 594   )
 595 {
 596   EFI_STATUS                   Status;
 597   HII_THUNK_CONTEXT            *ThunkContext;
 598
 599   ThunkContext = AllocateZeroPool (sizeof (HII_THUNK_CONTEXT));
 600   ASSERT (ThunkContext != NULL);
 601
 602   ThunkContext->Signature = HII_THUNK_CONTEXT_SIGNATURE;
 603   ThunkContext->IfrPackageCount = IfrPackageCount;
 604   ThunkContext->StringPackageCount = StringPackageCount;
 605   Status = AllocateHiiHandle (&ThunkContext->FwHiiHandle);
 606   if (EFI_ERROR (Status)) {
 607     return NULL;
 608   }
 609
 610   InitializeListHead (&ThunkContext->QuestionIdMapListHead);
 611   InitializeListHead (&ThunkContext->OneOfOptionMapListHead);
 612
 613
 614   return ThunkContext;
 615
 616 }
 617
 618 VOID
 619 DestroyThunkContext (
 620   IN HII_THUNK_CONTEXT          *ThunkContext
 621   )
 622 {
 623   ASSERT (ThunkContext != NULL);
 624
 625   FreeHiiHandle (ThunkContext->FwHiiHandle);
 626
 627   DestroyQuestionIdMap (&ThunkContext->QuestionIdMapListHead);
 628
 629   DestoryOneOfOptionMap (&ThunkContext->OneOfOptionMapListHead);
 630
 631   RemoveEntryList (&ThunkContext->Link);
 632
 633   FreePool (ThunkContext);
 634 }
 635
 636
 637 VOID
 638 DestroyQuestionIdMap (
 639   IN LIST_ENTRY     *QuestionIdMapListHead
 640   )
 641 {
 642   QUESTION_ID_MAP           *IdMap;
 643   QUESTION_ID_MAP_ENTRY     *IdMapEntry;
 644   LIST_ENTRY                *Link;
 645   LIST_ENTRY                *Link2;
 646
 647   while (!IsListEmpty (QuestionIdMapListHead)) {
 648     Link = GetFirstNode (QuestionIdMapListHead);
 649
 650     IdMap = QUESTION_ID_MAP_FROM_LINK (Link);
 651
 652     while (!IsListEmpty (&IdMap->MapEntryListHead)) {
 653       Link2 = GetFirstNode (&IdMap->MapEntryListHead);
 654
 655       IdMapEntry = QUESTION_ID_MAP_ENTRY_FROM_LINK (Link2);
 656
 657       RemoveEntryList (Link2);
 658
 659       FreePool (IdMapEntry);
 660     }
 661
 662     RemoveEntryList (Link);
 663     FreePool (IdMap);
 664   }
 665 }
 666
 667 VOID
 668 DestoryOneOfOptionMap (
 669   IN LIST_ENTRY     *OneOfOptionMapListHead
 670   )
 671 {
 672   ONE_OF_OPTION_MAP         *Map;
 673   ONE_OF_OPTION_MAP_ENTRY   *MapEntry;
 674   LIST_ENTRY                *Link;
 675   LIST_ENTRY                *Link2;
 676
 677   while (!IsListEmpty (OneOfOptionMapListHead)) {
 678     Link = GetFirstNode (OneOfOptionMapListHead);
 679
 680     Map = ONE_OF_OPTION_MAP_FROM_LINK (Link);
 681
 682     while (!IsListEmpty (&Map->OneOfOptionMapEntryListHead)) {
 683       Link2 = GetFirstNode (&Map->OneOfOptionMapEntryListHead);
 684
 685       MapEntry = ONE_OF_OPTION_MAP_ENTRY_FROM_LINK (Link2);
 686
 687       RemoveEntryList (Link2);
 688
 689       FreePool (MapEntry);
 690     }
 691
 692     RemoveEntryList (Link);
 693     FreePool (Map);
 694   }
 695 }
 696
 697
 698
 699