EdkCompatibilityPkg/Compatibility/FrameworkHiiToUefiHiiThunk/ConfigAccess.c

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