EdkCompatibilityPkg/Compatibility/FrameworkHiiOnUefiHiiThunk/ConfigAccess.c

   1 /**@file
   2   This file implements functions related to Config Access Protocols installed by
   3   by HII Thunk Modules. These Config access Protocols are used to thunk UEFI Config
   4   Access Callback to Framework HII Callback and EFI Variable Set/Get operations.
   5
   6 Copyright (c) 2008, Intel Corporation
   7 All rights reserved. This program and the accompanying materials
   8 are licensed and made available under the terms and conditions of the BSD License
   9 which accompanies this distribution.  The full text of the license may be found at
  10 http://opensource.org/licenses/bsd-license.php
  11
  12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  14
  15 **/
  16
  17 #include "HiiDatabase.h"
  18 #include "UefiIfrParser.h"
  19
  20 BOOLEAN            mHiiPackageListUpdated = FALSE;
  21
  22 HII_VENDOR_DEVICE_PATH  mUefiHiiVendorDevicePath = {
  23   {
  24     {
  25       {
  26         HARDWARE_DEVICE_PATH,
  27         HW_VENDOR_DP,
  28         {
  29           (UINT8) (sizeof (HII_VENDOR_DEVICE_PATH_NODE)),
  30           (UINT8) ((sizeof (HII_VENDOR_DEVICE_PATH_NODE)) >> 8)
  31         }
  32       },
  33       EFI_CALLER_ID_GUID
  34     },
  35     0,
  36     0
  37   },
  38   {
  39     END_DEVICE_PATH_TYPE,
  40     END_ENTIRE_DEVICE_PATH_SUBTYPE,
  41     {
  42       (UINT8) (sizeof (EFI_DEVICE_PATH_PROTOCOL)),
  43       (UINT8) ((sizeof (EFI_DEVICE_PATH_PROTOCOL)) >> 8)
  44     }
  45   }
  46 };
  47
  48 CONFIG_ACCESS_PRIVATE gConfigAccessPrivateTempate = {
  49   CONFIG_ACCESS_PRIVATE_SIGNATURE,
  50   {
  51     ThunkExtractConfig,
  52     ThunkRouteConfig,
  53     ThunkCallback
  54   }, //ConfigAccessProtocol
  55   NULL, //FormCallbackProtocol
  56   NULL
  57 };
  58
  59 /**
  60   Get the first EFI_IFR_VARSTORE from the FormSet.
  61
  62   @param FormSet                  The Form Set.
  63
  64   @retval FORMSET_STORAGE *       Return the first EFI_IFR_VARSTORE.
  65   @retval NULL                    If the Form Set does not have EFI_IFR_VARSTORE.
  66 **/
  67 FORMSET_STORAGE *
  68 GetFirstStorageOfFormSet (
  69   IN CONST FORM_BROWSER_FORMSET * FormSet
  70   )
  71 {
  72   LIST_ENTRY             *StorageList;
  73   FORMSET_STORAGE        *Storage;
  74
  75   StorageList = GetFirstNode (&FormSet->StorageListHead);
  76
  77   if (!IsNull (&FormSet->StorageListHead, StorageList)) {
  78     Storage = FORMSET_STORAGE_FROM_LINK (StorageList);
  79     return Storage;
  80   }
  81
  82   return NULL;
  83 }
  84
  85 /**
  86   Get the EFI_IFR_VARSTORE where the Question's value is stored.
  87
  88   @param FormSet                  The Form Set.
  89
  90   @retval FORMSET_STORAGE *       The EFI_IFR_VARSTORE where the Question's value is stored.
  91   @retval NULL                    If the Form Set does not have EFI_IFR_VARSTORE.
  92 **/
  93 FORMSET_STORAGE *
  94 GetStorageFromQuestionId (
  95   IN CONST FORM_BROWSER_FORMSET * FormSet,
  96   IN       EFI_QUESTION_ID        QuestionId
  97   )
  98 {
  99   LIST_ENTRY             *FormList;
 100   LIST_ENTRY             *StatementList;
 101   FORM_BROWSER_FORM      *Form;
 102   FORM_BROWSER_STATEMENT *Statement;
 103
 104   FormList = GetFirstNode (&FormSet->FormListHead);
 105
 106   while (!IsNull (&FormSet->FormListHead, FormList)) {
 107     Form = FORM_BROWSER_FORM_FROM_LINK (FormList);
 108
 109     StatementList = GetFirstNode (&Form->StatementListHead);
 110
 111     while (!IsNull (&Form->StatementListHead, StatementList)) {
 112       Statement = FORM_BROWSER_STATEMENT_FROM_LINK (StatementList);
 113       if ((QuestionId == Statement->QuestionId) && (Statement->Storage != NULL)) {
 114         //
 115         // UEFI Question ID is unique in a FormSet.
 116         //
 117         ASSERT (Statement->Storage->Type == EFI_HII_VARSTORE_BUFFER);
 118         return Statement->Storage;
 119       }
 120       StatementList = GetNextNode (&Form->StatementListHead, StatementList);
 121     }
 122
 123     FormList = GetNextNode (&FormSet->FormListHead, FormList);
 124   }
 125
 126   return NULL;
 127 }
 128
 129 /**
 130   Get the EFI_IFR_VARSTORE based the ID.
 131
 132   @param FormSet                  The Form Set.
 133
 134   @retval FORMSET_STORAGE *       The EFI_IFR_VARSTORE with the ID.
 135   @retval NULL                    If the Form Set does not have EFI_IFR_VARSTORE with such ID.
 136 **/
 137 FORMSET_STORAGE *
 138 GetStorageFromVarStoreId (
 139   IN CONST FORM_BROWSER_FORMSET * FormSet,
 140   IN       EFI_VARSTORE_ID        VarStoreId
 141   )
 142 {
 143   LIST_ENTRY             *StorageList;
 144   FORMSET_STORAGE        *Storage;
 145
 146   StorageList = GetFirstNode (&FormSet->StorageListHead);
 147
 148   while (!IsNull (&FormSet->StorageListHead, StorageList)) {
 149     Storage = FORMSET_STORAGE_FROM_LINK (StorageList);
 150
 151     if (VarStoreId == Storage->VarStoreId) {
 152       return Storage;
 153     }
 154
 155     StorageList = GetNextNode (&FormSet->StorageListHead, StorageList);
 156   }
 157
 158   return NULL;
 159 }
 160
 161 /**
 162   Get the EFI_IFR_VARSTORE based the <ConfigHdr> string in a <ConfigRequest>
 163   or a <ConfigResp> string.
 164
 165   @param FormSet                  The Form Set.
 166   @param ConfigString             The Configuration String which is defined by UEFI HII.
 167
 168   @retval FORMSET_STORAGE *       The EFI_IFR_VARSTORE where the Question's value is stored.
 169   @retval NULL                    If the Form Set does not have EFI_IFR_VARSTORE with such ID.
 170 **/
 171 FORMSET_STORAGE *
 172 GetStorageFromConfigString (
 173   IN CONST FORM_BROWSER_FORMSET *FormSet,
 174   IN  CONST EFI_STRING          ConfigString
 175   )
 176 {
 177   LIST_ENTRY             *StorageList;
 178   FORMSET_STORAGE        *Storage;
 179   CHAR16                 *Name;
 180
 181   StorageList = GetFirstNode (&FormSet->StorageListHead);
 182
 183   while (!IsNull (&FormSet->StorageListHead, StorageList)) {
 184     Storage = FORMSET_STORAGE_FROM_LINK (StorageList);
 185
 186     if ((Storage->VarStoreId == FormSet->DefaultVarStoreId) && (FormSet->OriginalDefaultVarStoreName != NULL)) {
 187       Name = FormSet->OriginalDefaultVarStoreName;
 188     } else {
 189       Name = Storage->Name;
 190     }
 191
 192     if (HiiIsConfigHdrMatch (ConfigString, &Storage->Guid, Name)) {
 193       return Storage;
 194     }
 195
 196     StorageList = GetNextNode (&FormSet->StorageListHead, StorageList);
 197   }
 198
 199    return NULL;
 200 }
 201
 202 /**
 203   This function installs a EFI_CONFIG_ACCESS_PROTOCOL instance for a form package registered
 204   by a module using Framework HII Protocol Interfaces.
 205
 206   UEFI HII require EFI_HII_CONFIG_ACCESS_PROTOCOL to be installed on a EFI_HANDLE, so
 207   that Setup Utility can load the Buffer Storage using this protocol.
 208
 209   @param Packages             The Package List.
 210   @param ThunkContext         The Thunk Context.
 211
 212   @retval  EFI_SUCCESS        The Config Access Protocol is installed successfully.
 213   @retval  EFI_OUT_RESOURCE   There is not enough memory.
 214
 215 **/
 216 EFI_STATUS
 217 InstallDefaultConfigAccessProtocol (
 218   IN  CONST EFI_HII_PACKAGES                    *Packages,
 219   IN  OUT   HII_THUNK_CONTEXT                   *ThunkContext
 220   )
 221 {
 222   EFI_STATUS                                  Status;
 223   CONFIG_ACCESS_PRIVATE                       *ConfigAccessInstance;
 224   HII_VENDOR_DEVICE_PATH                      *HiiVendorPath;
 225
 226   ASSERT (ThunkContext->IfrPackageCount != 0);
 227
 228   ConfigAccessInstance = AllocateCopyPool (
 229                            sizeof (CONFIG_ACCESS_PRIVATE),
 230                            &gConfigAccessPrivateTempate
 231                            );
 232   ASSERT (ConfigAccessInstance != NULL);
 233
 234   //
 235   // Use memory address as unique ID to distinguish from different device paths
 236   // This function may be called multi times by the framework HII driver.
 237   //
 238   HiiVendorPath = AllocateCopyPool (
 239                            sizeof (HII_VENDOR_DEVICE_PATH),
 240                            &mUefiHiiVendorDevicePath
 241                            );
 242   ASSERT (HiiVendorPath != NULL);
 243
 244   HiiVendorPath->Node.UniqueId = (UINT64) ((UINTN) HiiVendorPath);
 245
 246   Status = gBS->InstallMultipleProtocolInterfaces (
 247           &ThunkContext->UefiHiiDriverHandle,
 248           &gEfiDevicePathProtocolGuid,
 249           HiiVendorPath,
 250           &gEfiHiiConfigAccessProtocolGuid,
 251           &ConfigAccessInstance->ConfigAccessProtocol,
 252           NULL
 253           );
 254   ASSERT_EFI_ERROR (Status);
 255
 256   ConfigAccessInstance->ThunkContext = ThunkContext;
 257
 258   return EFI_SUCCESS;
 259 }
 260
 261 /**
 262   This function un-installs the EFI_CONFIG_ACCESS_PROTOCOL instance for a form package registered
 263   by a module using Framework HII Protocol Interfaces.
 264
 265   ASSERT if no Config Access is found for such pakcage list or failed to uninstall the protocol.
 266
 267   @param ThunkContext         The Thunk Context.
 268
 269 **/
 270 VOID
 271 UninstallDefaultConfigAccessProtocol (
 272   IN  HII_THUNK_CONTEXT                   *ThunkContext
 273   )
 274 {
 275   EFI_STATUS                      Status;
 276   EFI_HII_CONFIG_ACCESS_PROTOCOL  *ConfigAccess;
 277   HII_VENDOR_DEVICE_PATH          *HiiVendorPath;
 278
 279   Status = gBS->HandleProtocol (
 280                   ThunkContext->UefiHiiDriverHandle,
 281                   &gEfiHiiConfigAccessProtocolGuid,
 282                   (VOID **) &ConfigAccess
 283                   );
 284   ASSERT_EFI_ERROR (Status);
 285
 286   Status = gBS->HandleProtocol (
 287                   ThunkContext->UefiHiiDriverHandle,
 288                   &gEfiDevicePathProtocolGuid,
 289                   (VOID **) &HiiVendorPath
 290                   );
 291   ASSERT_EFI_ERROR (Status);
 292
 293   Status = gBS->UninstallMultipleProtocolInterfaces (
 294                   ThunkContext->UefiHiiDriverHandle,
 295                   &gEfiDevicePathProtocolGuid,
 296                   HiiVendorPath,
 297                   &gEfiHiiConfigAccessProtocolGuid,
 298                   ConfigAccess,
 299                   NULL
 300                   );
 301   ASSERT_EFI_ERROR (Status);
 302
 303 }
 304
 305
 306 /**
 307    Wrap the EFI_HII_CONFIG_ACCESS_PROTOCOL.ExtractConfig to a call to EFI_FORM_CALLBACK_PROTOCOL.NvRead.
 308
 309    @param BufferStorage         The key with all attributes needed to call EFI_FORM_CALLBACK_PROTOCOL.NvRead.
 310    @param FwFormCallBack    The EFI_FORM_CALLBACK_PROTOCOL registered by Framework HII module.
 311    @param Data                     The data read.
 312    @param DataSize                 The size of data.
 313
 314    @retval EFI_STATUS              The status returned by the EFI_FORM_CALLBACK_PROTOCOL.NvWrite.
 315    @retval EFI_INVALID_PARAMETER   If the EFI_FORM_CALLBACK_PROTOCOL.NvRead return the size information of the data
 316                                    does not match what has been recorded early in he BUFFER_STORAGE_ENTRY.
 317  **/
 318 EFI_STATUS
 319 CallFormCallBack (
 320   IN       FORMSET_STORAGE                            *BufferStorage,
 321   IN       EFI_FORM_CALLBACK_PROTOCOL                 *FwFormCallBack,
 322   OUT      VOID                                       **Data,
 323   OUT      UINTN                                      *DataSize
 324   )
 325 {
 326   EFI_STATUS          Status;
 327
 328   *DataSize = 0;
 329   *Data     = NULL;
 330
 331   Status = FwFormCallBack->NvRead (
 332               FwFormCallBack,
 333               BufferStorage->Name,
 334               &BufferStorage->Guid,
 335               NULL,
 336               DataSize,
 337               *Data
 338               );
 339   if (Status == EFI_BUFFER_TOO_SMALL) {
 340     if (BufferStorage->Size != *DataSize) {
 341       ASSERT (FALSE);
 342       return EFI_INVALID_PARAMETER;
 343     }
 344
 345     *Data = AllocateZeroPool (*DataSize);
 346     if (Data == NULL) {
 347       return EFI_OUT_OF_RESOURCES;
 348     }
 349
 350     FwFormCallBack->NvRead (
 351                   FwFormCallBack,
 352                   BufferStorage->Name,
 353                   &BufferStorage->Guid,
 354                   NULL,
 355                   DataSize,
 356                   *Data
 357                   );
 358   }
 359
 360   return Status;
 361 }
 362
 363
 364 /**
 365    Wrap the EFI_HII_CONFIG_ACCESS_PROTOCOL.ExtractConfig to a call to UEFI Variable Get Service.
 366
 367    @param BufferStorage        The key with all attributes needed to call a UEFI Variable Get Service.
 368    @param Data                    The data read.
 369    @param DataSize                The size of data.
 370
 371    If the UEFI Variable Get Service return the size information of the data
 372    does not match what has been recorded early in he BUFFER_STORAGE_ENTRY.
 373    then ASSERT.
 374
 375    @retval EFI_STATUS              The status returned by the UEFI Variable Get Service.
 376    @retval EFI_INVALID_PARAMETER   If the UEFI Variable Get Service return the size information of the data
 377                                    does not match what has been recorded early in he BUFFER_STORAGE_ENTRY.
 378  **/
 379
 380 EFI_STATUS
 381 GetUefiVariable (
 382   IN       FORMSET_STORAGE                            *BufferStorage,
 383   OUT      VOID                                       **Data,
 384   OUT      UINTN                                      *DataSize
 385   )
 386 {
 387   EFI_STATUS          Status;
 388
 389   *DataSize = 0;
 390   *Data = NULL;
 391   Status = gRT->GetVariable (
 392               BufferStorage->Name,
 393               &BufferStorage->Guid,
 394               NULL,
 395               DataSize,
 396               *Data
 397               );
 398   if (Status == EFI_BUFFER_TOO_SMALL) {
 399
 400     if (BufferStorage->Size != *DataSize) {
 401       ASSERT (FALSE);
 402       return EFI_INVALID_PARAMETER;
 403     }
 404
 405     *Data = AllocateZeroPool (*DataSize);
 406     if (Data == NULL) {
 407       return EFI_OUT_OF_RESOURCES;
 408     }
 409
 410     Status = gRT->GetVariable (
 411                 BufferStorage->Name,
 412                 &BufferStorage->Guid,
 413                 NULL,
 414                 DataSize,
 415                 *Data
 416                 );
 417   }
 418
 419   return Status;
 420 }
 421
 422 /**
 423
 424   This function implement the EFI_HII_CONFIG_ACCESS_PROTOCOL.ExtractConfig
 425   so that data can be read from the data storage such as UEFI Variable or module's
 426   customized storage exposed by EFI_FRAMEWORK_CALLBACK.
 427
 428    @param This        Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL
 429    @param Request     A null-terminated Unicode string in <ConfigRequest> format. Note that this
 430                       includes the routing information as well as the configurable name / value pairs. It is
 431                       invalid for this string to be in <MultiConfigRequest> format.
 432
 433    @param Progress    On return, points to a character in the Request string. Points to the string's null
 434                       terminator if request was successful. Points to the most recent '&' before the first
 435                       failing name / value pair (or the beginning of the string if the failure is in the first
 436                       name / value pair) if the request was not successful
 437    @param Results     A null-terminated Unicode string in <ConfigAltResp> format which has all
 438                       values filled in for the names in the Request string. String to be allocated by the called
 439                       function.
 440
 441    @retval EFI_INVALID_PARAMETER   If there is no Buffer Storage for this Config Access instance.
 442    @retval EFI_SUCCESS             The setting is retrived successfully.
 443    @retval !EFI_SUCCESS            The error returned by UEFI Get Variable or Framework Form Callback Nvread.
 444  **/
 445 EFI_STATUS
 446 EFIAPI
 447 ThunkExtractConfig (
 448   IN  CONST EFI_HII_CONFIG_ACCESS_PROTOCOL   *This,
 449   IN  CONST EFI_STRING                       Request,
 450   OUT EFI_STRING                             *Progress,
 451   OUT EFI_STRING                             *Results
 452   )
 453 {
 454   EFI_STATUS                                  Status;
 455   CONFIG_ACCESS_PRIVATE                       *ConfigAccess;
 456   FORMSET_STORAGE                             *BufferStorage;
 457   VOID                                        *Data;
 458   UINTN                                       DataSize;
 459
 460   if (Request == NULL) {
 461     return EFI_NOT_FOUND;
 462   }
 463
 464   Data = NULL;
 465   ConfigAccess = CONFIG_ACCESS_PRIVATE_FROM_PROTOCOL (This);
 466
 467   BufferStorage = GetStorageFromConfigString (ConfigAccess->ThunkContext->FormSet, Request);
 468
 469   if (BufferStorage == NULL) {
 470     *Progress = (EFI_STRING) Request;
 471     return EFI_NOT_FOUND;
 472   }
 473
 474   if (ConfigAccess->ThunkContext->NvMapOverride == NULL) {
 475     //
 476     // NvMapOverride is not used. Get the Storage data from EFI Variable or Framework Form Callback.
 477     //
 478     if (ConfigAccess->FormCallbackProtocol == NULL ||
 479         ConfigAccess->FormCallbackProtocol->NvRead == NULL) {
 480       Status = GetUefiVariable (
 481                  BufferStorage,
 482                  &Data,
 483                  &DataSize
 484                  );
 485     } else {
 486       Status = CallFormCallBack (
 487                  BufferStorage,
 488                  ConfigAccess->FormCallbackProtocol,
 489                   &Data,
 490                   &DataSize
 491                  );
 492     }
 493   } else {
 494     //
 495     // Use the NvMapOverride.
 496     //
 497     DataSize = BufferStorage->Size;
 498     Data = AllocateCopyPool (DataSize, ConfigAccess->ThunkContext->NvMapOverride);
 499
 500     if (Data != NULL) {
 501       Status = EFI_SUCCESS;
 502     } else {
 503       Status = EFI_OUT_OF_RESOURCES;
 504     }
 505   }
 506
 507   if (!EFI_ERROR (Status)) {
 508     Status = mHiiConfigRoutingProtocol->BlockToConfig (
 509                                             mHiiConfigRoutingProtocol,
 510                                             Request,
 511                                             Data,
 512                                             DataSize,
 513                                             Results,
 514                                             Progress
 515                                             );
 516   }
 517
 518   if (Data != NULL) {
 519     FreePool (Data);
 520   }
 521   return Status;
 522 }
 523
 524 /**
 525   This function implement the EFI_HII_CONFIG_ACCESS_PROTOCOL.RouteConfig
 526   so that data can be written to the data storage such as UEFI Variable or module's
 527   customized storage exposed by EFI_FRAMEWORK_CALLBACK.
 528
 529    @param This             Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL
 530    @param Configuration    A null-terminated Unicode string in <ConfigResp> format.
 531    @param Progress         A pointer to a string filled in with the offset of the most recent '&' before the first
 532                            failing name / value pair (or the beginning of the string if the failure is in the first
 533                            name / value pair) or the terminating NULL if all was successful.
 534
 535    @retval EFI_INVALID_PARAMETER   If there is no Buffer Storage for this Config Access instance.
 536    @retval EFI_SUCCESS             The setting is saved successfully.
 537    @retval !EFI_SUCCESS            The error returned by UEFI Set Variable or Framework Form Callback Nvwrite.
 538 **/
 539 EFI_STATUS
 540 EFIAPI
 541 ThunkRouteConfig (
 542   IN  CONST EFI_HII_CONFIG_ACCESS_PROTOCOL   *This,
 543   IN  CONST EFI_STRING                       Configuration,
 544   OUT EFI_STRING                             *Progress
 545   )
 546 {
 547   EFI_STATUS                                  Status;
 548   CONFIG_ACCESS_PRIVATE                       *ConfigAccess;
 549   FORMSET_STORAGE                             *BufferStorage;
 550   VOID                                        *Data;
 551   UINTN                                       DataSize;
 552   UINTN                                       DataSize2;
 553   UINTN                                       LastModifiedByteIndex;
 554   BOOLEAN                                     ResetRequired;
 555   BOOLEAN                                     DataAllocated;
 556
 557   if (Configuration == NULL) {
 558     return EFI_INVALID_PARAMETER;
 559   }
 560
 561   Data = NULL;
 562   ConfigAccess = CONFIG_ACCESS_PRIVATE_FROM_PROTOCOL (This);
 563
 564   BufferStorage = GetStorageFromConfigString (ConfigAccess->ThunkContext->FormSet, Configuration);
 565
 566   if (BufferStorage == NULL) {
 567     *Progress = Configuration;
 568     return EFI_NOT_FOUND;
 569   }
 570
 571   DataSize2     = BufferStorage->Size;
 572   if (ConfigAccess->ThunkContext->NvMapOverride == NULL) {
 573     DataAllocated = TRUE;
 574     if (ConfigAccess->FormCallbackProtocol == NULL ||
 575         ConfigAccess->FormCallbackProtocol->NvRead == NULL) {
 576       Status = GetUefiVariable (
 577                  BufferStorage,
 578                  &Data,
 579                  &DataSize
 580                  );
 581     } else {
 582       Status = CallFormCallBack (
 583                  BufferStorage,
 584                  ConfigAccess->FormCallbackProtocol,
 585                   &Data,
 586                   &DataSize
 587                  );
 588     }
 589   } else {
 590     //
 591     // ConfigToBlock will convert the Config String and update the NvMapOverride accordingly.
 592     //
 593     Status = EFI_SUCCESS;
 594     Data = ConfigAccess->ThunkContext->NvMapOverride;
 595     DataSize      = DataSize2;
 596     DataAllocated = FALSE;
 597   }
 598   if (EFI_ERROR (Status) || (DataSize2 != DataSize)) {
 599     if (Data == NULL) {
 600       Data = AllocateZeroPool (DataSize2);
 601     }
 602   }
 603
 604   Status = mHiiConfigRoutingProtocol->ConfigToBlock (
 605                                           mHiiConfigRoutingProtocol,
 606                                           Configuration,
 607                                           Data,
 608                                           &LastModifiedByteIndex,
 609                                           Progress
 610                                           );
 611   if (EFI_ERROR (Status)) {
 612     goto Done;
 613   }
 614
 615   if (ConfigAccess->ThunkContext->NvMapOverride == NULL) {
 616     if (ConfigAccess->FormCallbackProtocol == NULL ||
 617         ConfigAccess->FormCallbackProtocol->NvWrite == NULL) {
 618       Status = gRT->SetVariable (
 619                     BufferStorage->Name,
 620                     &BufferStorage->Guid,
 621                     EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
 622                     DataSize2,
 623                     Data
 624                     );
 625     } else {
 626       Status = ConfigAccess->FormCallbackProtocol->NvWrite (
 627                     ConfigAccess->FormCallbackProtocol,
 628                     BufferStorage->Name,
 629                     &BufferStorage->Guid,
 630                     EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
 631                     DataSize2,
 632                     Data,
 633                     &ResetRequired
 634                     );
 635
 636     }
 637   }
 638
 639 Done:
 640   if (DataAllocated && (Data != NULL)) {
 641     FreePool (Data);
 642   }
 643
 644   return Status;
 645 }
 646
 647 /**
 648   Build the EFI_IFR_DATA_ARRAY which will be used to pass to
 649   EFI_FORM_CALLBACK_PROTOCOL.Callback. Check definition of EFI_IFR_DATA_ARRAY
 650   for details.
 651
 652   ASSERT if the Question Type is not EFI_IFR_TYPE_NUM_SIZE_* or EFI_IFR_TYPE_STRING.
 653
 654    @param This             Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL
 655    @param QuestionId       The Question ID.
 656    @param Type             The Question Type.
 657    @param Value            The Question Value.
 658    @param NvMapAllocated   On output indicates if a buffer is allocated for NvMap.
 659
 660    @return A pointer to EFI_IFR_DATA_ARRAY. The caller must free this buffer allocated.
 661 **/
 662 EFI_IFR_DATA_ARRAY *
 663 CreateIfrDataArray (
 664   IN    CONFIG_ACCESS_PRIVATE         *ConfigAccess,
 665   IN    EFI_QUESTION_ID               QuestionId,
 666   IN    UINT8                         Type,
 667   IN    EFI_IFR_TYPE_VALUE            *Value,
 668   OUT   BOOLEAN                       *NvMapAllocated
 669   )
 670 {
 671   EFI_IFR_DATA_ARRAY                *IfrDataArray;
 672   EFI_IFR_DATA_ENTRY                *IfrDataEntry;
 673   UINTN                             BrowserDataSize;
 674   FORMSET_STORAGE                   *BufferStorage;
 675   UINTN                             Size;
 676   EFI_STRING                        String;
 677
 678   *NvMapAllocated = FALSE;
 679
 680   String = NULL;
 681
 682   switch (Type) {
 683     case EFI_IFR_TYPE_NUM_SIZE_8:
 684     case EFI_IFR_TYPE_NUM_SIZE_16:
 685     case EFI_IFR_TYPE_NUM_SIZE_32:
 686     case EFI_IFR_TYPE_NUM_SIZE_64:
 687     case EFI_IFR_TYPE_BOOLEAN:
 688       Size = sizeof (*Value);
 689       break;
 690
 691     case EFI_IFR_TYPE_STRING:
 692       if (Value->string == 0) {
 693         Size = 0;
 694       } else {
 695         String = HiiGetString (ConfigAccess->ThunkContext->UefiHiiHandle, Value->string, NULL);
 696         ASSERT (String != NULL);
 697
 698         Size = StrSize (String);
 699       }
 700       break;
 701
 702     default:
 703       ASSERT (FALSE);
 704       Size = 0;
 705       break;
 706   }
 707
 708   IfrDataArray = AllocateZeroPool (sizeof (EFI_IFR_DATA_ARRAY) + sizeof (EFI_IFR_DATA_ENTRY) + Size);
 709   ASSERT (IfrDataArray != NULL);
 710
 711   BufferStorage  = GetStorageFromQuestionId (ConfigAccess->ThunkContext->FormSet, QuestionId);
 712
 713   if (BufferStorage == NULL) {
 714     //
 715     // The QuestionId is not associated with a Buffer Storage.
 716     // Try to get the first Buffer Storage then.
 717     //
 718     BufferStorage = GetFirstStorageOfFormSet (ConfigAccess->ThunkContext->FormSet);
 719   }
 720
 721   if (BufferStorage != NULL) {
 722     BrowserDataSize = BufferStorage->Size;
 723
 724     if (ConfigAccess->ThunkContext->NvMapOverride == NULL) {
 725       *NvMapAllocated = TRUE;
 726       IfrDataArray->NvRamMap = AllocateZeroPool (BrowserDataSize);
 727     } else {
 728       *NvMapAllocated = FALSE;
 729       IfrDataArray->NvRamMap = ConfigAccess->ThunkContext->NvMapOverride;
 730     }
 731
 732     ASSERT (HiiGetBrowserData (&BufferStorage->Guid, BufferStorage->Name, BrowserDataSize, (UINT8 *) IfrDataArray->NvRamMap));
 733     IfrDataEntry = (EFI_IFR_DATA_ENTRY *) (IfrDataArray + 1);
 734
 735     switch (Type) {
 736       case EFI_IFR_TYPE_NUM_SIZE_8:
 737       case EFI_IFR_TYPE_NUM_SIZE_16:
 738       case EFI_IFR_TYPE_NUM_SIZE_32:
 739       case EFI_IFR_TYPE_NUM_SIZE_64:
 740       case EFI_IFR_TYPE_BOOLEAN:
 741         CopyMem (&IfrDataEntry->Data, &(Value->u8), sizeof (*Value));
 742         break;
 743
 744       case EFI_IFR_TYPE_STRING:
 745         if (Size != 0) {
 746           ASSERT (String != NULL);
 747           StrCpy ((CHAR16 *) &IfrDataEntry->Data, String);
 748           FreePool (String);
 749         }
 750         break;
 751       default:
 752         ASSERT (FALSE);
 753         break;
 754     }
 755
 756     //
 757     // Need to fiil in the information for the rest of field for EFI_IFR_DATA_ENTRY.
 758     // It seems that no implementation is found to use other fields. Leave them uninitialized for now.
 759     //
 760     //UINT8   OpCode;           // Likely a string, numeric, or one-of
 761     //UINT8   Length;           // Length of the EFI_IFR_DATA_ENTRY packet
 762     //UINT16  Flags;            // Flags settings to determine what behavior is desired from the browser after the callback
 763     //VOID    *Data;            // The data in the form based on the op-code type - this is not a pointer to the data, the data follows immediately
 764     // If the OpCode is a OneOf or Numeric type - Data is a UINT16 value
 765     // If the OpCode is a String type - Data is a CHAR16[x] type
 766     // If the OpCode is a Checkbox type - Data is a UINT8 value
 767     // If the OpCode is a NV Access type - Data is a FRAMEWORK_EFI_IFR_NV_DATA structure
 768   }
 769
 770   return IfrDataArray;
 771 }
 772
 773 /**
 774   If a NvMapOverride is passed in to EFI_FORM_BROWSER_PROTOCOL.SendForm, the Form Browser
 775   needs to be informed when data changed in NvMapOverride. This function will invoke
 776   SetBrowserData () to set internal data of Form Browser.
 777
 778   @param  ConfigAccess   The Config Access Private Context.
 779   @param  QuestionId     The Question Id that invokes the callback.
 780
 781
 782 **/
 783 VOID
 784 SyncBrowserDataForNvMapOverride (
 785   IN    CONST CONFIG_ACCESS_PRIVATE         *ConfigAccess,
 786   IN          EFI_QUESTION_ID               QuestionId
 787   )
 788 {
 789   FORMSET_STORAGE   *BufferStorage;
 790   BOOLEAN           CheckFlag;
 791   UINTN             BrowserDataSize;
 792
 793   if (ConfigAccess->ThunkContext->NvMapOverride != NULL) {
 794
 795     BufferStorage = GetStorageFromQuestionId (ConfigAccess->ThunkContext->FormSet, QuestionId);
 796
 797     if (BufferStorage == NULL) {
 798       //
 799       // QuestionId is a statement without Storage.
 800       // 1) It is a Goto.
 801       //
 802       //
 803       BufferStorage = GetFirstStorageOfFormSet (ConfigAccess->ThunkContext->FormSet);
 804     }
 805
 806     //
 807     // If NvMapOverride is not NULL, this Form must have at least one Buffer Type Variable Storage.
 808     //
 809     ASSERT (BufferStorage != NULL);
 810
 811     BrowserDataSize = BufferStorage->Size;
 812
 813     CheckFlag = HiiSetBrowserData (&BufferStorage->Guid, BufferStorage->Name, BrowserDataSize, ConfigAccess->ThunkContext->NvMapOverride, NULL);
 814     ASSERT (CheckFlag);
 815   }
 816
 817 }
 818
 819 /**
 820   Free up resource allocated for a EFI_IFR_DATA_ARRAY by CreateIfrDataArray ().
 821
 822   @param Array              The EFI_IFR_DATA_ARRAY allocated.
 823   @param NvMapAllocated     If the NvRamMap is allocated for EFI_IFR_DATA_ARRAY.
 824
 825 **/
 826 VOID
 827 DestroyIfrDataArray (
 828   IN  EFI_IFR_DATA_ARRAY           *Array,
 829   IN  BOOLEAN                      NvMapAllocated
 830   )
 831 {
 832   if (Array != NULL) {
 833     if (NvMapAllocated) {
 834       FreePool (Array->NvRamMap);
 835     }
 836
 837     FreePool (Array);
 838   }
 839 }
 840
 841 /**
 842   Get the ONE_OF_OPTION_MAP_ENTRY for a QuestionId that invokes the
 843   EFI_FORM_CALLBACK_PROTOCOL.Callback. The information is needed as
 844   the callback mechanism for EFI_IFR_ONE_OF_OPTION is changed from
 845   EFI_IFR_ONE_OF_OPTION in Framework IFR. Check EFI_IFR_GUID_OPTIONKEY
 846   for detailed information.
 847
 848   @param ThunkContext   The Thunk Context.
 849   @param QuestionId     The Question Id.
 850   @param Type           The Question Type.
 851   @param Value          The One Of Option's value.
 852
 853   @return The ONE_OF_OPTION_MAP_ENTRY found.
 854   @retval NULL If no entry is found.
 855 **/
 856 ONE_OF_OPTION_MAP_ENTRY *
 857 GetOneOfOptionMapEntry (
 858   IN  HII_THUNK_CONTEXT              *ThunkContext,
 859   IN  EFI_QUESTION_ID                QuestionId,
 860   IN  UINT8                          Type,
 861   IN  EFI_IFR_TYPE_VALUE             *Value
 862   )
 863 {
 864   LIST_ENTRY              *Link;
 865   LIST_ENTRY              *Link2;
 866   ONE_OF_OPTION_MAP_ENTRY *OneOfOptionMapEntry;
 867   ONE_OF_OPTION_MAP       *OneOfOptionMap;
 868   FORM_BROWSER_FORMSET    *FormSet;
 869
 870   FormSet = ThunkContext->FormSet;
 871
 872   Link = GetFirstNode (&FormSet->OneOfOptionMapListHead);
 873
 874   while (!IsNull (&FormSet->OneOfOptionMapListHead, Link)) {
 875     OneOfOptionMap = ONE_OF_OPTION_MAP_FROM_LINK(Link);
 876     if (OneOfOptionMap->QuestionId == QuestionId) {
 877       ASSERT (OneOfOptionMap->ValueType == Type);
 878
 879       Link2 = GetFirstNode (&OneOfOptionMap->OneOfOptionMapEntryListHead);
 880
 881       while (!IsNull (&OneOfOptionMap->OneOfOptionMapEntryListHead, Link2)) {
 882         OneOfOptionMapEntry = ONE_OF_OPTION_MAP_ENTRY_FROM_LINK (Link2);
 883
 884         if (CompareMem (Value, &OneOfOptionMapEntry->Value, sizeof (EFI_IFR_TYPE_VALUE)) == 0) {
 885           return OneOfOptionMapEntry;
 886         }
 887
 888         Link2 = GetNextNode (&OneOfOptionMap->OneOfOptionMapEntryListHead, Link2);
 889       }
 890     }
 891
 892     Link = GetNextNode (&FormSet->OneOfOptionMapListHead, Link);
 893   }
 894
 895
 896   return NULL;
 897 }
 898
 899 /**
 900   Functions which are registered to receive notification of
 901   database events have this prototype. The actual event is encoded
 902   in NotifyType. The following table describes how PackageType,
 903   PackageGuid, Handle, and Package are used for each of the
 904   notification types.
 905
 906   If any Pakcage List in database is updated, mHiiPackageListUpdated
 907   will be set. If mHiiPackageListUpdated is set, Framework ThunkCallback()
 908   will force the UEFI Setup Browser to save the uncommitted data. This
 909   is needed as Framework's Callback function may dynamically update
 910   opcode in a Package List. UEFI Setup Browser will quit itself and reparse
 911   the Package List's IFR and display it. UEFI Config Access's implementation
 912   is required to save the modified (SetBrowserData or directly save the data
 913   to NV storage). But Framework HII Modules is not aware of this rule. Therefore,
 914   we will enforce the rule in ThunkCallback (). The side effect of force saving
 915   of NV data is the NV flag in browser may not flag a update as data has already
 916   been saved to NV storage.
 917
 918   @param PackageType  Package type of the notification.
 919
 920   @param PackageGuid  If PackageType is
 921                       EFI_HII_PACKAGE_TYPE_GUID, then this is
 922                       the pointer to the GUID from the Guid
 923                       field of EFI_HII_PACKAGE_GUID_HEADER.
 924                       Otherwise, it must be NULL.
 925
 926   @param Package  Points to the package referred to by the
 927                   notification Handle The handle of the package
 928                   list which contains the specified package.
 929
 930   @param Handle       The HII handle.
 931
 932   @param NotifyType   The type of change concerning the
 933                       database. See
 934                       EFI_HII_DATABASE_NOTIFY_TYPE.
 935
 936 **/
 937 EFI_STATUS
 938 EFIAPI
 939 FormUpdateNotify (
 940   IN UINT8                              PackageType,
 941   IN CONST EFI_GUID                     *PackageGuid,
 942   IN CONST EFI_HII_PACKAGE_HEADER       *Package,
 943   IN EFI_HII_HANDLE                     Handle,
 944   IN EFI_HII_DATABASE_NOTIFY_TYPE       NotifyType
 945   )
 946 {
 947   mHiiPackageListUpdated = TRUE;
 948
 949   return EFI_SUCCESS;
 950 }
 951
 952 /**
 953   Wrap the EFI_HII_CONFIG_ACCESS_PROTOCOL.CallBack to EFI_FORM_CALLBACK_PROTOCOL.Callback. Therefor,
 954   the framework HII module willl do no porting and work with a UEFI HII SetupBrowser.
 955
 956    @param This                      Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
 957    @param Action                    Specifies the type of action taken by the browser. See EFI_BROWSER_ACTION_x.
 958    @param QuestionId                A unique value which is sent to the original exporting driver so that it can identify the
 959                                     type of data to expect. The format of the data tends to vary based on the opcode that
 960                                     generated the callback.
 961    @param Type                      The type of value for the question. See EFI_IFR_TYPE_x in
 962                                     EFI_IFR_ONE_OF_OPTION.
 963    @param Value                     A pointer to the data being sent to the original exporting driver. The type is specified
 964                                     by Type. Type EFI_IFR_TYPE_VALUE is defined in
 965                                     EFI_IFR_ONE_OF_OPTION.
 966    @param ActionRequest             On return, points to the action requested by the callback function. Type
 967                                     EFI_BROWSER_ACTION_REQUEST is specified in SendForm() in the Form
 968                                     Browser Protocol.
 969
 970    @retval EFI_UNSUPPORTED        If the Framework HII module does not register Callback although it specify the opcode under
 971                                   focuse to be INTERRACTIVE.
 972    @retval EFI_SUCCESS            The callback complete successfully.
 973    @retval !EFI_SUCCESS           The error code returned by EFI_FORM_CALLBACK_PROTOCOL.Callback.
 974
 975  **/
 976 EFI_STATUS
 977 EFIAPI
 978 ThunkCallback (
 979   IN  CONST EFI_HII_CONFIG_ACCESS_PROTOCOL   *This,
 980   IN  EFI_BROWSER_ACTION                     Action,
 981   IN  EFI_QUESTION_ID                        QuestionId,
 982   IN  UINT8                                  Type,
 983   IN  EFI_IFR_TYPE_VALUE                     *Value,
 984   OUT EFI_BROWSER_ACTION_REQUEST             *ActionRequest
 985   )
 986 {
 987   EFI_STATUS                                  Status;
 988   CONFIG_ACCESS_PRIVATE                       *ConfigAccess;
 989   EFI_FORM_CALLBACK_PROTOCOL                  *FormCallbackProtocol;
 990   EFI_HII_CALLBACK_PACKET                     *Packet;
 991   EFI_IFR_DATA_ARRAY                          *Data;
 992   EFI_IFR_DATA_ENTRY                          *DataEntry;
 993   UINT16                                      KeyValue;
 994   ONE_OF_OPTION_MAP_ENTRY                     *OneOfOptionMapEntry;
 995   EFI_HANDLE                                  NotifyHandle;
 996   EFI_INPUT_KEY                               Key;
 997   BOOLEAN                                     NvMapAllocated;
 998
 999   ASSERT (This != NULL);
1000   ASSERT (Value != NULL);
1001   ASSERT (ActionRequest != NULL);
1002
1003   *ActionRequest = EFI_BROWSER_ACTION_REQUEST_NONE;
1004
1005   ConfigAccess = CONFIG_ACCESS_PRIVATE_FROM_PROTOCOL (This);
1006
1007   FormCallbackProtocol = ConfigAccess->FormCallbackProtocol;
1008   if (FormCallbackProtocol == NULL) {
1009     ASSERT (FALSE);
1010     return EFI_UNSUPPORTED;
1011   }
1012
1013   //
1014   // Check if the QuestionId match a OneOfOption.
1015   //
1016   OneOfOptionMapEntry = GetOneOfOptionMapEntry (ConfigAccess->ThunkContext, QuestionId, Type, Value);
1017
1018   if (OneOfOptionMapEntry == NULL) {
1019     //
1020     // This is not a One-Of-Option opcode. QuestionId is the KeyValue
1021     //
1022     KeyValue = QuestionId;
1023   } else {
1024     //
1025     // Otherwise, use the original Key specified in One Of Option in the Framework VFR syntax.
1026     //
1027     KeyValue = OneOfOptionMapEntry->FwKey;
1028   }
1029
1030   //
1031   // Build the EFI_IFR_DATA_ARRAY
1032   //
1033   Data = CreateIfrDataArray (ConfigAccess, QuestionId, Type, Value, &NvMapAllocated);
1034
1035   Status = mHiiDatabase->RegisterPackageNotify (
1036                            mHiiDatabase,
1037                            EFI_HII_PACKAGE_FORMS,
1038                            NULL,
1039                            FormUpdateNotify,
1040                            EFI_HII_DATABASE_NOTIFY_REMOVE_PACK,
1041                            &NotifyHandle
1042                            );
1043   //
1044   //Call the Framework Callback function.
1045   //
1046   Packet =  NULL;
1047   Status =  FormCallbackProtocol->Callback (
1048               FormCallbackProtocol,
1049               KeyValue,
1050               Data,
1051               &Packet
1052               );
1053   SyncBrowserDataForNvMapOverride (ConfigAccess, QuestionId);
1054
1055   //
1056   // Callback require browser to perform action
1057   //
1058   if (EFI_ERROR (Status)) {
1059     if (Packet != NULL) {
1060       do {
1061         CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, Packet->String, NULL);
1062       } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);
1063     }
1064     //
1065     // Error Code in Status is discarded.
1066     //
1067   } else {
1068     if (Packet != NULL) {
1069         if (Packet->DataArray.EntryCount  == 1 && Packet->DataArray.NvRamMap == NULL) {
1070           DataEntry = (EFI_IFR_DATA_ENTRY *) ((UINT8 *) Packet + sizeof (EFI_IFR_DATA_ARRAY));
1071           if ((DataEntry->Flags & EXIT_REQUIRED) == EXIT_REQUIRED) {
1072               *ActionRequest = EFI_BROWSER_ACTION_REQUEST_EXIT;
1073           }
1074
1075           if ((DataEntry->Flags & SAVE_REQUIRED) == SAVE_REQUIRED) {
1076             Status = ConfigAccess->ConfigAccessProtocol.RouteConfig (
1077                                       &ConfigAccess->ConfigAccessProtocol,
1078                                       NULL,
1079                                       NULL
1080                                       );
1081           }
1082         }
1083         FreePool (Packet);
1084     }
1085   }
1086
1087   //
1088   // Unregister notify for Form package update
1089   //
1090   Status = mHiiDatabase->UnregisterPackageNotify (
1091                            mHiiDatabase,
1092                            NotifyHandle
1093                            );
1094   //
1095   // UEFI SetupBrowser behaves differently with Framework SetupBrowser when call back function
1096   // update any forms in HII database. UEFI SetupBrowser will re-parse the displaying form package and load
1097   // the values from variable storages. Framework SetupBrowser will only re-parse the displaying form packages.
1098   // To make sure customer's previous changes is saved and the changing question behaves as expected, we
1099   // issue a EFI_BROWSER_ACTION_REQUEST_SUBMIT to ask UEFI SetupBrowser to save the changes proceed to re-parse
1100   // the form and load all the variable storages.
1101   //
1102   if (*ActionRequest == EFI_BROWSER_ACTION_REQUEST_NONE && mHiiPackageListUpdated) {
1103     mHiiPackageListUpdated= FALSE;
1104     *ActionRequest = EFI_BROWSER_ACTION_REQUEST_SUBMIT;
1105   } else {
1106     if (ConfigAccess->ThunkContext->FormSet->SubClass == EFI_FRONT_PAGE_SUBCLASS ||
1107         ConfigAccess->ThunkContext->FormSet->SubClass == EFI_SINGLE_USE_SUBCLASS) {
1108       *ActionRequest = EFI_BROWSER_ACTION_REQUEST_EXIT;
1109     }
1110   }
1111
1112
1113   //
1114   // Clean up.
1115   //
1116   DestroyIfrDataArray (Data, NvMapAllocated);
1117
1118   return Status;
1119 }
1120