MdeModulePkg/Library/UefiIfrSupportLib/UefiIfrForm.c

   1 /** @file
   2 Utility functions which helps in opcode creation, HII configuration string manipulations,
   3 pop up window creations, setup browser persistence data set and get.
   4
   5 Copyright (c) 2007- 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 #include "UefiIfrLibraryInternal.h"
  17
  18 CONST EFI_FORM_BROWSER2_PROTOCOL      *mFormBrowser2     = NULL;
  19 CONST EFI_HII_CONFIG_ROUTING_PROTOCOL *mIfrSupportLibHiiConfigRouting = NULL;
  20 GLOBAL_REMOVE_IF_UNREFERENCED CONST CHAR8 mIfrSupportLibHexStr[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
  21
  22 //
  23 // Fake <ConfigHdr>
  24 //
  25 GLOBAL_REMOVE_IF_UNREFERENCED CONST UINT16 mFakeConfigHdr[] = L"GUID=00000000000000000000000000000000&NAME=0000&PATH=0";
  26
  27 /**
  28   This function locate FormBrowser2 protocols for later usage.
  29
  30   @return Status the status to locate protocol.
  31 **/
  32 EFI_STATUS
  33 LocateFormBrowser2Protocols (
  34   VOID
  35   )
  36 {
  37   EFI_STATUS Status;
  38   //
  39   // Locate protocols for later usage
  40   //
  41   if (mFormBrowser2 == NULL) {
  42     Status = gBS->LocateProtocol (&gEfiFormBrowser2ProtocolGuid, NULL, (VOID **) &mFormBrowser2);
  43     if (EFI_ERROR (Status)) {
  44       return Status;
  45     }
  46   }
  47
  48   if (mIfrSupportLibHiiConfigRouting == NULL) {
  49     Status = gBS->LocateProtocol (&gEfiHiiConfigRoutingProtocolGuid, NULL, (VOID **) &mIfrSupportLibHiiConfigRouting);
  50     if (EFI_ERROR (Status)) {
  51       return Status;
  52     }
  53   }
  54
  55   return EFI_SUCCESS;
  56 }
  57
  58 /**
  59   Draw a dialog and return the selected key.
  60
  61   @param  NumberOfLines          The number of lines for the dialog box
  62   @param  KeyValue               The EFI_KEY value returned if HotKey is TRUE..
  63   @param  String                 The first String to be displayed in the Pop-Up.
  64   @param  Marker                 A series of (quantity == NumberOfLines - 1) text
  65                                  strings which will be used to construct the dialog
  66                                  box
  67
  68   @retval EFI_SUCCESS            Displayed dialog and received user interaction
  69   @retval EFI_INVALID_PARAMETER  One of the parameters was invalid.
  70   @retval EFI_OUT_OF_RESOURCES   There is no enough available memory space.
  71
  72 **/
  73 EFI_STATUS
  74 EFIAPI
  75 IfrLibCreatePopUp2 (
  76   IN  UINTN                       NumberOfLines,
  77   OUT EFI_INPUT_KEY               *KeyValue,
  78   IN  CHAR16                      *String,
  79   IN  VA_LIST                     Marker
  80   )
  81 {
  82   UINTN                         Index;
  83   UINTN                         Count;
  84   UINTN                         Start;
  85   UINTN                         Top;
  86   CHAR16                        *StringPtr;
  87   UINTN                         LeftColumn;
  88   UINTN                         RightColumn;
  89   UINTN                         TopRow;
  90   UINTN                         BottomRow;
  91   UINTN                         DimensionsWidth;
  92   UINTN                         DimensionsHeight;
  93   EFI_INPUT_KEY                 Key;
  94   UINTN                         LargestString;
  95   CHAR16                        *StackString;
  96   EFI_STATUS                    Status;
  97   UINTN                         StringLen;
  98   CHAR16                        *LineBuffer;
  99   CHAR16                        **StringArray;
 100   EFI_EVENT                     TimerEvent;
 101   EFI_EVENT                     WaitList[2];
 102   UINTN                         CurrentAttribute;
 103   EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *ConOut;
 104
 105   if ((KeyValue == NULL) || (String == NULL)) {
 106     return EFI_INVALID_PARAMETER;
 107   }
 108
 109   TopRow      = 0;
 110   BottomRow   = 0;
 111   LeftColumn  = 0;
 112   RightColumn = 0;
 113
 114   ConOut = gST->ConOut;
 115   ConOut->QueryMode (ConOut, ConOut->Mode->Mode, &RightColumn, &BottomRow);
 116
 117   DimensionsWidth  = RightColumn - LeftColumn;
 118   DimensionsHeight = BottomRow - TopRow;
 119
 120   CurrentAttribute = ConOut->Mode->Attribute;
 121
 122   LineBuffer = AllocateZeroPool (DimensionsWidth * sizeof (CHAR16));
 123   if (LineBuffer == NULL) {
 124     return EFI_OUT_OF_RESOURCES;
 125   }
 126
 127   //
 128   // Determine the largest string in the dialog box
 129   // Notice we are starting with 1 since String is the first string
 130   //
 131   StringArray = AllocateZeroPool (NumberOfLines * sizeof (CHAR16 *));
 132   if (StringArray == NULL) {
 133     FreePool (LineBuffer);
 134     return EFI_OUT_OF_RESOURCES;
 135   }
 136   LargestString = StrLen (String);
 137   StringArray[0] = String;
 138
 139   for (Index = 1; Index < NumberOfLines; Index++) {
 140     StackString = VA_ARG (Marker, CHAR16 *);
 141
 142     if (StackString == NULL) {
 143       FreePool (LineBuffer);
 144       FreePool (StringArray);
 145       return EFI_INVALID_PARAMETER;
 146     }
 147
 148     StringArray[Index] = StackString;
 149     StringLen = StrLen (StackString);
 150     if (StringLen > LargestString) {
 151       LargestString = StringLen;
 152     }
 153   }
 154
 155   if ((LargestString + 2) > DimensionsWidth) {
 156     LargestString = DimensionsWidth - 2;
 157   }
 158
 159   //
 160   // Subtract the PopUp width from total Columns, allow for one space extra on
 161   // each end plus a border.
 162   //
 163   Start     = (DimensionsWidth - LargestString - 2) / 2 + LeftColumn + 1;
 164
 165   Top       = ((DimensionsHeight - NumberOfLines - 2) / 2) + TopRow - 1;
 166
 167   //
 168   // Disable cursor
 169   //
 170   ConOut->EnableCursor (ConOut, FALSE);
 171   ConOut->SetAttribute (ConOut, EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE);
 172
 173   StringPtr = &LineBuffer[0];
 174   *StringPtr++ = BOXDRAW_DOWN_RIGHT;
 175   for (Index = 0; Index < LargestString; Index++) {
 176     *StringPtr++ = BOXDRAW_HORIZONTAL;
 177   }
 178   *StringPtr++ = BOXDRAW_DOWN_LEFT;
 179   *StringPtr = L'\0';
 180
 181   ConOut->SetCursorPosition (ConOut, Start, Top);
 182   ConOut->OutputString (ConOut, LineBuffer);
 183
 184   for (Index = 0; Index < NumberOfLines; Index++) {
 185     StringPtr = &LineBuffer[0];
 186     *StringPtr++ = BOXDRAW_VERTICAL;
 187
 188     for (Count = 0; Count < LargestString; Count++) {
 189       StringPtr[Count] = L' ';
 190     }
 191
 192     StringLen = StrLen (StringArray[Index]);
 193     if (StringLen > LargestString) {
 194       StringLen = LargestString;
 195     }
 196     CopyMem (
 197       StringPtr + ((LargestString - StringLen) / 2),
 198       StringArray[Index],
 199       StringLen * sizeof (CHAR16)
 200       );
 201     StringPtr += LargestString;
 202
 203     *StringPtr++ = BOXDRAW_VERTICAL;
 204     *StringPtr = L'\0';
 205
 206     ConOut->SetCursorPosition (ConOut, Start, Top + 1 + Index);
 207     ConOut->OutputString (ConOut, LineBuffer);
 208   }
 209
 210   StringPtr = &LineBuffer[0];
 211   *StringPtr++ = BOXDRAW_UP_RIGHT;
 212   for (Index = 0; Index < LargestString; Index++) {
 213     *StringPtr++ = BOXDRAW_HORIZONTAL;
 214   }
 215   *StringPtr++ = BOXDRAW_UP_LEFT;
 216   *StringPtr = L'\0';
 217
 218   ConOut->SetCursorPosition (ConOut, Start, Top + NumberOfLines + 1);
 219   ConOut->OutputString (ConOut, LineBuffer);
 220
 221   do {
 222     Status = gBS->CreateEvent (EVT_TIMER, 0, NULL, NULL, &TimerEvent);
 223
 224     //
 225     // Set a timer event of 1 second expiration
 226     //
 227     gBS->SetTimer (
 228           TimerEvent,
 229           TimerRelative,
 230           10000000
 231           );
 232
 233     //
 234     // Wait for the keystroke event or the timer
 235     //
 236     WaitList[0] = gST->ConIn->WaitForKey;
 237     WaitList[1] = TimerEvent;
 238     Status      = gBS->WaitForEvent (2, WaitList, &Index);
 239
 240     //
 241     // Check for the timer expiration
 242     //
 243     if (!EFI_ERROR (Status) && Index == 1) {
 244       Status = EFI_TIMEOUT;
 245     }
 246
 247     gBS->CloseEvent (TimerEvent);
 248   } while (Status == EFI_TIMEOUT);
 249
 250   Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
 251   CopyMem (KeyValue, &Key, sizeof (EFI_INPUT_KEY));
 252
 253   ConOut->SetAttribute (ConOut, CurrentAttribute);
 254   ConOut->EnableCursor (ConOut, TRUE);
 255
 256   FreePool (LineBuffer);
 257   FreePool (StringArray);
 258
 259   return Status;
 260 }
 261
 262
 263 /**
 264   Draw a dialog and return the selected key.
 265
 266   @param  NumberOfLines          The number of lines for the dialog box
 267   @param  KeyValue               The EFI_KEY value returned if HotKey is TRUE..
 268   @param  String                 Pointer to the first string in the list
 269   @param  ...                    A series of (quantity == NumberOfLines - 1) text
 270                                  strings which will be used to construct the dialog
 271                                  box
 272
 273   @retval EFI_SUCCESS            Displayed dialog and received user interaction
 274   @retval EFI_INVALID_PARAMETER  One of the parameters was invalid.
 275
 276 **/
 277 EFI_STATUS
 278 EFIAPI
 279 IfrLibCreatePopUp (
 280   IN  UINTN                       NumberOfLines,
 281   OUT EFI_INPUT_KEY               *KeyValue,
 282   IN  CHAR16                      *String,
 283   ...
 284   )
 285 {
 286   EFI_STATUS                      Status;
 287   VA_LIST                         Marker;
 288
 289   VA_START (Marker, String);
 290
 291   Status = IfrLibCreatePopUp2 (NumberOfLines, KeyValue, String, Marker);
 292
 293   VA_END (Marker);
 294
 295   return Status;
 296 }
 297
 298 /**
 299     Extract block name from the array generated by VFR compiler. The name of
 300   this array is "Vfr + <StorageName> + BlockName", e.g. "VfrMyIfrNVDataBlockName".
 301   Format of this array is:
 302      Array length | 4-bytes
 303        Offset     | 2-bytes
 304        Width      | 2-bytes
 305        Offset     | 2-bytes
 306        Width      | 2-bytes
 307        ... ...
 308
 309     @param Buffer                 Array generated by VFR compiler.
 310     @param BlockName              The returned <BlockName>
 311
 312     @retval EFI_OUT_OF_RESOURCES   Run out of memory resource.
 313     @retval EFI_INVALID_PARAMETER  Buffer is NULL or BlockName is NULL.
 314     @retval EFI_SUCCESS            Operation successful.
 315
 316 **/
 317 EFI_STATUS
 318 ExtractBlockName (
 319   IN UINT8                        *Buffer,
 320   OUT CHAR16                      **BlockName
 321   )
 322
 323 {
 324   UINTN       Index;
 325   UINT32      Length;
 326   UINT32      BlockNameNumber;
 327   UINTN       HexStringBufferLen;
 328   CHAR16      *StringPtr;
 329
 330   if ((Buffer == NULL) || (BlockName == NULL)) {
 331     return EFI_INVALID_PARAMETER;
 332   }
 333
 334   //
 335   // Calculate number of Offset/Width pair
 336   //
 337   CopyMem (&Length, Buffer, sizeof (UINT32));
 338   BlockNameNumber = (Length - sizeof (UINT32)) / (sizeof (UINT16) * 2);
 339
 340   //
 341   // <BlockName> ::= &OFFSET=1234&WIDTH=1234
 342   //                 |   8  | 4 |  7   | 4 |
 343   //
 344   StringPtr = AllocateZeroPool ((BlockNameNumber * (8 + 4 + 7 + 4) + 1) * sizeof (CHAR16));
 345   if (StringPtr == NULL) {
 346     return EFI_OUT_OF_RESOURCES;
 347   }
 348   *BlockName = StringPtr;
 349
 350   Buffer += sizeof (UINT32);
 351   for (Index = 0; Index < BlockNameNumber; Index++) {
 352     StrCpy (StringPtr, L"&OFFSET=");
 353     StringPtr += 8;
 354
 355     HexStringBufferLen = 5;
 356     BufToHexString (StringPtr, &HexStringBufferLen, Buffer, sizeof (UINT16));
 357     Buffer += sizeof (UINT16);
 358     StringPtr += 4;
 359
 360     StrCpy (StringPtr, L"&WIDTH=");
 361     StringPtr += 7;
 362
 363     HexStringBufferLen = 5;
 364     BufToHexString (StringPtr, &HexStringBufferLen, Buffer, sizeof (UINT16));
 365     Buffer += sizeof (UINT16);
 366     StringPtr += 4;
 367   }
 368
 369   return EFI_SUCCESS;
 370 }
 371
 372 /**
 373
 374     Extract block config from the array generated by VFR compiler. The name of
 375   this array is "Vfr + <StorageName> + Default<HexCh>4", e.g. "VfrMyIfrNVDataDefault0000".
 376
 377     @param Buffer                - Array generated by VFR compiler.
 378     @param BlockConfig           - The returned <BlockConfig>
 379
 380     @retval EFI_OUT_OF_RESOURCES  - Run out of memory resource.
 381     @retval EFI_INVALID_PARAMETER - Buffer is NULL or BlockConfig is NULL.
 382     @retval EFI_SUCCESS           - Operation successful.
 383
 384 **/
 385 EFI_STATUS
 386 ExtractBlockConfig (
 387   IN UINT8                        *Buffer,
 388   OUT CHAR16                      **BlockConfig
 389   )
 390 {
 391   UINT32      Length;
 392   UINT16      Width;
 393   UINTN       HexStringBufferLen;
 394   CHAR16      *StringPtr;
 395   UINT8       *BufferEnd;
 396   CHAR16      *StringEnd;
 397   EFI_STATUS  Status;
 398
 399   if ((Buffer == NULL) || (BlockConfig == NULL)) {
 400     return EFI_INVALID_PARAMETER;
 401   }
 402
 403   //
 404   // Calculate length of AltResp string
 405   // Format of Default value array is:
 406   //  Array length | 4-bytes
 407   //        Offset | 2-bytes
 408   //        Width  | 2-bytes
 409   //        Value  | Variable length
 410   //        Offset | 2-bytes
 411   //        Width  | 2-bytes
 412   //        Value  | Variable length
 413   //        ... ...
 414   // When value is 1 byte in length, overhead of AltResp string will be maximum,
 415   //  BlockConfig ::= <&OFFSET=1234&WIDTH=1234&VALUE=12>+
 416   //                   |   8   | 4  |  7   | 4 |  7  |2|
 417   // so the maximum length of BlockConfig could be calculated as:
 418   // (ArrayLength / 5) * (8 + 4 + 7 + 4 + 7 + 2) = ArrayLength * 6.4 < ArrayLength * 7
 419   //
 420   CopyMem (&Length, Buffer, sizeof (UINT32));
 421   BufferEnd = Buffer + Length;
 422   StringPtr = AllocatePool (Length * 7 * sizeof (CHAR16));
 423   *BlockConfig = StringPtr;
 424   if (StringPtr == NULL) {
 425       return EFI_OUT_OF_RESOURCES;
 426   }
 427   StringEnd = StringPtr + (Length * 7);
 428
 429   Buffer += sizeof (UINT32);
 430   while (Buffer < BufferEnd) {
 431     StrCpy (StringPtr, L"&OFFSET=");
 432     StringPtr += 8;
 433
 434     HexStringBufferLen = 5;
 435     BufToHexString (StringPtr, &HexStringBufferLen, Buffer, sizeof (UINT16));
 436     Buffer += sizeof (UINT16);
 437     StringPtr += 4;
 438
 439     StrCpy (StringPtr, L"&WIDTH=");
 440     StringPtr += 7;
 441
 442     HexStringBufferLen = 5;
 443     BufToHexString (StringPtr, &HexStringBufferLen, Buffer, sizeof (UINT16));
 444     CopyMem (&Width, Buffer, sizeof (UINT16));
 445     Buffer += sizeof (UINT16);
 446     StringPtr += 4;
 447
 448     StrCpy (StringPtr, L"&VALUE=");
 449     StringPtr += 7;
 450
 451     HexStringBufferLen = StringEnd - StringPtr;
 452     Status = BufToHexString (StringPtr, &HexStringBufferLen, Buffer, Width);
 453     if (EFI_ERROR (Status)) {
 454       return Status;
 455     }
 456     Buffer += Width;
 457     StringPtr += (Width * 2);
 458   }
 459
 460   return EFI_SUCCESS;
 461 }
 462
 463 /**
 464     Construct <ConfigAltResp> for a buffer storage.
 465
 466     @param ConfigRequest           The Config request string. If set to NULL, all the
 467                                    configurable elements will be extracted from BlockNameArray.
 468     @param ConfigAltResp           The returned <ConfigAltResp>.
 469     @param Progress                On return, points to a character in the Request.
 470     @param Guid                    GUID of the buffer storage.
 471     @param Name                    Name of the buffer storage.
 472     @param DriverHandle            The DriverHandle which is used to invoke HiiDatabase
 473                                    protocol interface NewPackageList().
 474     @param BufferStorage           Content of the buffer storage.
 475     @param BufferStorageSize       Length in bytes of the buffer storage.
 476     @param BlockNameArray          Array generated by VFR compiler.
 477     @param NumberAltCfg            Number of Default value array generated by VFR compiler.
 478                                    The sequential input parameters will be number of
 479                                    AltCfgId and DefaultValueArray pairs. When set to 0,
 480                                    there will be no <AltResp>.
 481
 482     retval EFI_OUT_OF_RESOURCES  Run out of memory resource.
 483     retval EFI_INVALID_PARAMETER ConfigAltResp is NULL.
 484     retval EFI_SUCCESS           Operation successful.
 485
 486 **/
 487 EFI_STATUS
 488 ConstructConfigAltResp (
 489   IN  EFI_STRING                  ConfigRequest,  OPTIONAL
 490   OUT EFI_STRING                  *Progress,
 491   OUT EFI_STRING                  *ConfigAltResp,
 492   IN  EFI_GUID                    *Guid,
 493   IN  CHAR16                      *Name,
 494   IN  EFI_HANDLE                  *DriverHandle,
 495   IN  VOID                        *BufferStorage,
 496   IN  UINTN                       BufferStorageSize,
 497   IN  VOID                        *BlockNameArray, OPTIONAL
 498   IN  UINTN                       NumberAltCfg,
 499   ...
 500 //IN  UINT16                      AltCfgId,
 501 //IN  VOID                        *DefaultValueArray,
 502   )
 503 {
 504   EFI_STATUS                      Status;
 505   CHAR16                          *ConfigHdr;
 506   CHAR16                          *BlockName;
 507   CHAR16                          *DescHdr;
 508   CHAR16                          *StringPtr;
 509   CHAR16                          **AltCfg;
 510   UINT16                          AltCfgId;
 511   VOID                            *DefaultValueArray;
 512   UINTN                           StrBufferLen;
 513   EFI_STRING                      ConfigResp;
 514   EFI_STRING                      TempStr;
 515   VA_LIST                         Args;
 516   UINTN                           AltRespLen;
 517   UINTN                           Index;
 518   BOOLEAN                         NeedFreeConfigRequest;
 519   EFI_HII_CONFIG_ROUTING_PROTOCOL *HiiConfigRouting;
 520   UINTN                           Len;
 521
 522   if (ConfigAltResp == NULL) {
 523     return EFI_INVALID_PARAMETER;
 524   }
 525
 526   DescHdr = NULL;
 527   StringPtr = NULL;
 528   AltCfg    = NULL;
 529   ConfigResp = NULL;
 530   BlockName = NULL;
 531   NeedFreeConfigRequest = FALSE;
 532
 533   //
 534   // Construct <ConfigHdr> : "GUID=...&NAME=...&PATH=..."
 535   //
 536   ConfigHdr = NULL;
 537   StrBufferLen = 0;
 538   Status = ConstructConfigHdr (
 539              ConfigHdr,
 540              &StrBufferLen,
 541              Guid,
 542              Name,
 543              DriverHandle
 544              );
 545   ASSERT (Status == EFI_BUFFER_TOO_SMALL);
 546   ConfigHdr = AllocateZeroPool (StrBufferLen);
 547   if (ConfigHdr == NULL) {
 548     Status = EFI_OUT_OF_RESOURCES;
 549     goto Exit;
 550   }
 551   Status = ConstructConfigHdr (
 552              ConfigHdr,
 553              &StrBufferLen,
 554              Guid,
 555              Name,
 556              DriverHandle
 557              );
 558
 559   if (EFI_ERROR (Status)) {
 560     goto Exit;
 561   }
 562
 563   //
 564   // Construct <ConfigResp>
 565   //
 566   if (ConfigRequest == NULL) {
 567     //
 568     // If ConfigRequest is set to NULL, export all configurable elements in BlockNameArray
 569     //
 570     Status = ExtractBlockName (BlockNameArray, &BlockName);
 571     if (EFI_ERROR (Status)) {
 572       goto Exit;
 573     }
 574
 575     Len = StrSize (ConfigHdr);
 576     ConfigRequest = AllocateZeroPool (Len + StrSize (BlockName) - sizeof (CHAR16));
 577     if (ConfigRequest == NULL) {
 578       Status = EFI_OUT_OF_RESOURCES;
 579       goto Exit;
 580     }
 581
 582     StrCpy (ConfigRequest, ConfigHdr);
 583     StrCat (ConfigRequest, BlockName);
 584     NeedFreeConfigRequest = TRUE;
 585
 586   }
 587
 588   Status = gBS->LocateProtocol (&gEfiHiiConfigRoutingProtocolGuid, NULL, (VOID **) &HiiConfigRouting);
 589   if (EFI_ERROR (Status)) {
 590     return Status;
 591   }
 592
 593   Status = HiiConfigRouting->BlockToConfig (
 594                                HiiConfigRouting,
 595                                ConfigRequest,
 596                                BufferStorage,
 597                                BufferStorageSize,
 598                                &ConfigResp,
 599                                (Progress == NULL) ? &TempStr : Progress
 600                                );
 601   if (EFI_ERROR (Status)) {
 602     return Status;
 603   }
 604
 605   AltRespLen = 0;
 606   //
 607   // Construct <AltResp>
 608   //
 609   if (NumberAltCfg > 0) {
 610     DescHdr = AllocateZeroPool (NumberAltCfg * 16 * sizeof (CHAR16));
 611     if (DescHdr == NULL) {
 612       Status = EFI_OUT_OF_RESOURCES;
 613       goto Exit;
 614     }
 615
 616     StringPtr = DescHdr;
 617     AltCfg = AllocateZeroPool (NumberAltCfg * sizeof (CHAR16 *));
 618     if (AltCfg == NULL) {
 619       Status = EFI_OUT_OF_RESOURCES;
 620       goto Exit;
 621     }
 622
 623     VA_START (Args, NumberAltCfg);
 624     for (Index = 0; Index < NumberAltCfg; Index++) {
 625       AltCfgId = (UINT16) VA_ARG (Args, UINT16);
 626       DefaultValueArray = (UINT8 *) VA_ARG (Args, VOID *);
 627
 628       //
 629       // '&' <ConfigHdr>
 630       //
 631       AltRespLen += (StrLen (ConfigHdr) + 1);
 632
 633       StringPtr = DescHdr + Index * 16;
 634       StrCpy (StringPtr, L"&ALTCFG=");
 635       AltRespLen += (8 + sizeof (UINT16) * 2);
 636
 637       StrBufferLen = 5;
 638       BufToHexString (StringPtr + 8, &StrBufferLen, (UINT8 *) &AltCfgId, sizeof (UINT16));
 639       Status = ExtractBlockConfig (DefaultValueArray, &AltCfg[Index]);
 640       if (EFI_ERROR (Status)) {
 641         goto Exit;
 642       }
 643       AltRespLen += StrLen (AltCfg[Index]);
 644     }
 645     VA_END (Args);
 646   }
 647
 648   //
 649   // Generate the final <ConfigAltResp>
 650   //
 651   StrBufferLen = (StrLen ((CHAR16 *) ConfigResp) + AltRespLen + 1) * sizeof (CHAR16);
 652   TempStr = AllocateZeroPool (StrBufferLen);
 653   *ConfigAltResp = TempStr;
 654   if (TempStr == NULL) {
 655     goto Exit;
 656   }
 657
 658   //
 659   // <ConfigAltResp> ::= <ConfigResp> ['&' <AltResp>]*
 660   //
 661   StrCpy (TempStr, ConfigResp);
 662   for (Index = 0; Index < NumberAltCfg; Index++) {
 663     StrCat (TempStr, L"&");
 664     StrCat (TempStr, ConfigHdr);
 665     StrCat (TempStr, DescHdr + Index * 16);
 666     StrCat (TempStr, AltCfg[Index]);
 667
 668     FreePool (AltCfg[Index]);
 669   }
 670
 671 Exit:
 672   if (NeedFreeConfigRequest) {
 673     FreePool (ConfigRequest);
 674   }
 675   FreePool (ConfigHdr);
 676   if (ConfigResp != NULL) {
 677     FreePool (ConfigResp);
 678   }
 679
 680   if (BlockName != NULL) {
 681     FreePool (BlockName);
 682   }
 683
 684   if (NumberAltCfg > 0) {
 685     FreePool (DescHdr);
 686     FreePool (AltCfg);
 687   }
 688
 689   return EFI_SUCCESS;
 690 }
 691
 692 /**
 693   Swap bytes in the buffer. This is a internal function.
 694
 695   @param  Buffer                 Binary buffer.
 696   @param  BufferSize             Size of the buffer in bytes.
 697
 698   @return None.
 699
 700 **/
 701 VOID
 702 SwapBuffer (
 703   IN OUT UINT8     *Buffer,
 704   IN UINTN         BufferSize
 705   )
 706 {
 707   UINTN  Index;
 708   UINT8  Temp;
 709   UINTN  SwapCount;
 710
 711   SwapCount = BufferSize / 2;
 712   for (Index = 0; Index < SwapCount; Index++) {
 713     Temp = Buffer[Index];
 714     Buffer[Index] = Buffer[BufferSize - 1 - Index];
 715     Buffer[BufferSize - 1 - Index] = Temp;
 716   }
 717 }
 718
 719 /**
 720   Converts the unicode character of the string from uppercase to lowercase.
 721   This is a internal function.
 722
 723   @param Str     String to be converted
 724
 725 **/
 726 VOID
 727 EFIAPI
 728 ToLower (
 729   IN OUT CHAR16    *Str
 730   )
 731 {
 732   CHAR16      *Ptr;
 733
 734   for (Ptr = Str; *Ptr != L'\0'; Ptr++) {
 735     if (*Ptr >= L'A' && *Ptr <= L'Z') {
 736       *Ptr = (CHAR16) (*Ptr - L'A' + L'a');
 737     }
 738   }
 739 }
 740
 741
 742 /**
 743   Converts binary buffer to Unicode string in reversed byte order from BufToHexString().
 744
 745   @param  Str                    String for output
 746   @param  Buffer                 Binary buffer.
 747   @param  BufferSize             Size of the buffer in bytes.
 748
 749   @retval EFI_SUCCESS            The function completed successfully.
 750   @retval EFI_OUT_OF_RESOURCES   There is no enough available memory space.
 751
 752 **/
 753 EFI_STATUS
 754 EFIAPI
 755 BufInReverseOrderToHexString (
 756   IN OUT CHAR16    *Str,
 757   IN UINT8         *Buffer,
 758   IN UINTN         BufferSize
 759   )
 760 {
 761   EFI_STATUS  Status;
 762   UINT8       *NewBuffer;
 763   UINTN       StrBufferLen;
 764
 765   NewBuffer = AllocateCopyPool (BufferSize, Buffer);
 766   if (NewBuffer == NULL) {
 767     return EFI_OUT_OF_RESOURCES;
 768   }
 769   SwapBuffer (NewBuffer, BufferSize);
 770
 771   StrBufferLen = BufferSize * sizeof (CHAR16) + 1;
 772   Status = BufToHexString (Str, &StrBufferLen, NewBuffer, BufferSize);
 773
 774   FreePool (NewBuffer);
 775   //
 776   // Convert the uppercase to lowercase since <HexAf> is defined in lowercase format.
 777   //
 778   ToLower (Str);
 779
 780   return Status;
 781 }
 782
 783
 784 /**
 785   Converts Hex String to binary buffer in reversed byte order from HexStringToBuf().
 786
 787   @param  Buffer                 Pointer to buffer that receives the data.
 788   @param  BufferSize             Length in bytes of the buffer to hold converted
 789                                  data. If routine return with EFI_SUCCESS,
 790                                  containing length of converted data. If routine
 791                                  return with EFI_BUFFER_TOO_SMALL, containg length
 792                                  of buffer desired.
 793   @param  Str                    String to be converted from.
 794
 795   @retval EFI_SUCCESS            The function completed successfully.
 796   @retval RETURN_BUFFER_TOO_SMALL   The input BufferSize is too small to hold the output. BufferSize
 797                                  will be updated to the size required for the converstion.
 798
 799 **/
 800 EFI_STATUS
 801 EFIAPI
 802 HexStringToBufInReverseOrder (
 803   IN OUT UINT8         *Buffer,
 804   IN OUT UINTN         *BufferSize,
 805   IN CHAR16            *Str
 806   )
 807 {
 808   EFI_STATUS  Status;
 809   UINTN       ConvertedStrLen;
 810
 811   ConvertedStrLen = 0;
 812   Status = HexStringToBuf (Buffer, BufferSize, Str, &ConvertedStrLen);
 813   if (!EFI_ERROR (Status)) {
 814     SwapBuffer (Buffer, (ConvertedStrLen + 1) / 2);
 815   }
 816
 817   return Status;
 818 }
 819
 820 /**
 821   Convert binary representation Config string (e.g. "0041004200430044") to the
 822   original string (e.g. "ABCD"). Config string appears in <ConfigHdr> (i.e.
 823   "&NAME=<string>"), or Name/Value pair in <ConfigBody> (i.e. "label=<string>").
 824
 825   @param UnicodeString  Original Unicode string.
 826   @param StrBufferLen   On input: Length in bytes of buffer to hold the Unicode string.
 827                                     Includes tailing '\0' character.
 828                                     On output:
 829                                       If return EFI_SUCCESS, containing length of Unicode string buffer.
 830                                       If return EFI_BUFFER_TOO_SMALL, containg length of string buffer desired.
 831   @param ConfigString   Binary representation of Unicode String, <string> := (<HexCh>4)+
 832
 833   @retval EFI_SUCCESS          Operation completes successfully.
 834   @retval EFI_BUFFER_TOO_SMALL The string buffer is too small.
 835
 836 **/
 837 EFI_STATUS
 838 EFIAPI
 839 ConfigStringToUnicode (
 840   IN OUT CHAR16                *UnicodeString,
 841   IN OUT UINTN                 *StrBufferLen,
 842   IN CHAR16                    *ConfigString
 843   )
 844 {
 845   UINTN       Index;
 846   UINTN       Len;
 847   UINTN       BufferSize;
 848   CHAR16      BackupChar;
 849
 850   Len = StrLen (ConfigString) / 4;
 851   BufferSize = (Len + 1) * sizeof (CHAR16);
 852
 853   if (*StrBufferLen < BufferSize) {
 854     *StrBufferLen = BufferSize;
 855     return EFI_BUFFER_TOO_SMALL;
 856   }
 857
 858   *StrBufferLen = BufferSize;
 859
 860   for (Index = 0; Index < Len; Index++) {
 861     BackupChar = ConfigString[4];
 862     ConfigString[4] = L'\0';
 863
 864     HexStringToBuf ((UINT8 *) UnicodeString, &BufferSize, ConfigString, NULL);
 865
 866     ConfigString[4] = BackupChar;
 867
 868     ConfigString += 4;
 869     UnicodeString += 1;
 870   }
 871
 872   //
 873   // Add tailing '\0' character
 874   //
 875   *UnicodeString = L'\0';
 876
 877   return EFI_SUCCESS;
 878 }
 879
 880 /**
 881   Convert Unicode string to binary representation Config string, e.g.
 882   "ABCD" => "0041004200430044". Config string appears in <ConfigHdr> (i.e.
 883   "&NAME=<string>"), or Name/Value pair in <ConfigBody> (i.e. "label=<string>").
 884
 885   @param ConfigString   Binary representation of Unicode String, <string> := (<HexCh>4)+
 886   @param  StrBufferLen  On input: Length in bytes of buffer to hold the Unicode string.
 887                                     Includes tailing '\0' character.
 888                                     On output:
 889                                       If return EFI_SUCCESS, containing length of Unicode string buffer.
 890                                       If return EFI_BUFFER_TOO_SMALL, containg length of string buffer desired.
 891   @param  UnicodeString  Original Unicode string.
 892
 893   @retval EFI_SUCCESS           Operation completes successfully.
 894   @retval EFI_BUFFER_TOO_SMALL  The string buffer is too small.
 895
 896 **/
 897 EFI_STATUS
 898 EFIAPI
 899 UnicodeToConfigString (
 900   IN OUT CHAR16                *ConfigString,
 901   IN OUT UINTN                 *StrBufferLen,
 902   IN CHAR16                    *UnicodeString
 903   )
 904 {
 905   UINTN       Index;
 906   UINTN       Len;
 907   UINTN       BufferSize;
 908   CHAR16      *String;
 909
 910   Len = StrLen (UnicodeString);
 911   BufferSize = (Len * 4 + 1) * sizeof (CHAR16);
 912
 913   if (*StrBufferLen < BufferSize) {
 914     *StrBufferLen = BufferSize;
 915     return EFI_BUFFER_TOO_SMALL;
 916   }
 917
 918   *StrBufferLen = BufferSize;
 919   String        = ConfigString;
 920
 921   for (Index = 0; Index < Len; Index++) {
 922     BufToHexString (ConfigString, &BufferSize, (UINT8 *) UnicodeString, 2);
 923
 924     ConfigString += 4;
 925     UnicodeString += 1;
 926   }
 927
 928   //
 929   // Add tailing '\0' character
 930   //
 931   *ConfigString = L'\0';
 932
 933   //
 934   // Convert the uppercase to lowercase since <HexAf> is defined in lowercase format.
 935   //
 936   ToLower (String);
 937   return EFI_SUCCESS;
 938 }
 939
 940 /**
 941   Construct <ConfigHdr> using routing information GUID/NAME/PATH.
 942
 943   @param  ConfigHdr              Pointer to the ConfigHdr string.
 944   @param  StrBufferLen           On input: Length in bytes of buffer to hold the
 945                                  ConfigHdr string. Includes tailing '\0' character.
 946                                  On output: If return EFI_SUCCESS, containing
 947                                  length of ConfigHdr string buffer. If return
 948                                  EFI_BUFFER_TOO_SMALL, containg length of string
 949                                  buffer desired.
 950   @param  Guid                   Routing information: GUID.
 951   @param  Name                   Routing information: NAME.
 952   @param  DriverHandle           Driver handle which contains the routing
 953                                  information: PATH.
 954
 955   @retval EFI_SUCCESS            Operation completes successfully.
 956   @retval EFI_BUFFER_TOO_SMALL   The ConfigHdr string buffer is too small.
 957
 958 **/
 959 EFI_STATUS
 960 EFIAPI
 961 ConstructConfigHdr (
 962   IN OUT CHAR16                *ConfigHdr,
 963   IN OUT UINTN                 *StrBufferLen,
 964   IN CONST EFI_GUID            *Guid,
 965   IN CHAR16                    *Name, OPTIONAL
 966   IN EFI_HANDLE                *DriverHandle
 967   )
 968 {
 969   EFI_STATUS                Status;
 970   UINTN                     NameStrLen;
 971   UINTN                     DevicePathSize;
 972   UINTN                     BufferSize;
 973   CHAR16                    *StrPtr;
 974   EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
 975
 976   if (Name == NULL) {
 977     //
 978     // There will be no "NAME" in <ConfigHdr> for  Name/Value storage
 979     //
 980     NameStrLen = 0;
 981   } else {
 982     //
 983     // For buffer storage
 984     //
 985     NameStrLen = StrLen (Name);
 986   }
 987
 988   //
 989   // Retrieve DevicePath Protocol associated with this HiiPackageList
 990   //
 991   Status = gBS->HandleProtocol (
 992                   DriverHandle,
 993                   &gEfiDevicePathProtocolGuid,
 994                   (VOID **) &DevicePath
 995                   );
 996   if (EFI_ERROR (Status)) {
 997     return Status;
 998   }
 999
1000   DevicePathSize = GetDevicePathSize (DevicePath);
1001
1002   //
1003   // GUID=<HexCh>32&NAME=<Char>NameStrLen&PATH=<HexChar>DevicePathStrLen <NULL>
1004   // | 5  |   32   |  6  |  NameStrLen*4 |  6  |    DevicePathStrLen    | 1 |
1005   //
1006   BufferSize = (5 + 32 + 6 + NameStrLen * 4 + 6 + DevicePathSize * 2 + 1) * sizeof (CHAR16);
1007   if (*StrBufferLen < BufferSize) {
1008     *StrBufferLen = BufferSize;
1009     return EFI_BUFFER_TOO_SMALL;
1010   }
1011
1012   *StrBufferLen = BufferSize;
1013
1014   StrPtr = ConfigHdr;
1015
1016   StrCpy (StrPtr, L"GUID=");
1017   StrPtr += 5;
1018   BufInReverseOrderToHexString (StrPtr, (UINT8 *) Guid, sizeof (EFI_GUID));
1019   StrPtr += 32;
1020
1021   //
1022   // Convert name string, e.g. name "ABCD" => "&NAME=0041004200430044"
1023   //
1024   StrCpy (StrPtr, L"&NAME=");
1025   StrPtr += 6;
1026   if (Name != NULL) {
1027     BufferSize = (NameStrLen * 4 + 1) * sizeof (CHAR16);
1028     UnicodeToConfigString (StrPtr, &BufferSize, Name);
1029     StrPtr += (NameStrLen * 4);
1030   }
1031
1032   StrCpy (StrPtr, L"&PATH=");
1033   StrPtr += 6;
1034   BufInReverseOrderToHexString (StrPtr, (UINT8 *) DevicePath, DevicePathSize);
1035
1036   return EFI_SUCCESS;
1037 }
1038
1039 /**
1040   Determines if the Routing data (Guid and Name) is correct in <ConfigHdr>.
1041
1042   @param ConfigString  Either <ConfigRequest> or <ConfigResp>.
1043   @param StorageGuid   GUID of the storage.
1044   @param StorageName   Name of the stoarge.
1045
1046   @retval TRUE         Routing information is correct in ConfigString.
1047   @retval FALSE        Routing information is incorrect in ConfigString.
1048
1049 **/
1050 BOOLEAN
1051 IsConfigHdrMatch (
1052   IN EFI_STRING                ConfigString,
1053   IN EFI_GUID                  *StorageGuid, OPTIONAL
1054   IN CHAR16                    *StorageName  OPTIONAL
1055   )
1056 {
1057   EFI_STATUS  Status;
1058   BOOLEAN     Match;
1059   EFI_GUID    Guid;
1060   CHAR16      *Name;
1061   CHAR16      *StrPtr;
1062   UINTN       BufferSize;
1063
1064   //
1065   // <ConfigHdr> ::=
1066   // GUID=<HexCh>32&NAME=<Char>NameStrLen&PATH=<HexChar>DevicePathStrLen <NULL>
1067   // | 5  |   32   |  6  |  NameStrLen*4 |  6  |    DevicePathStrLen    | 1 |
1068   //
1069   if (StrLen (ConfigString) <= (5 + 32 + 6)) {
1070     return FALSE;
1071   }
1072
1073   //
1074   // Compare GUID
1075   //
1076   if (StorageGuid != NULL) {
1077
1078     StrPtr = ConfigString + 5 + 32;
1079     if (*StrPtr != L'&') {
1080       return FALSE;
1081     }
1082     *StrPtr = L'\0';
1083
1084     BufferSize = sizeof (EFI_GUID);
1085     Status = HexStringToBufInReverseOrder (
1086                (UINT8 *) &Guid,
1087                &BufferSize,
1088                ConfigString + 5
1089                );
1090     *StrPtr = L'&';
1091
1092     if (EFI_ERROR (Status)) {
1093       return FALSE;
1094     }
1095
1096     if (!CompareGuid (&Guid, StorageGuid)) {
1097       return FALSE;
1098     }
1099   }
1100
1101   //
1102   // Compare Name
1103   //
1104   Match = TRUE;
1105   if (StorageName != NULL) {
1106     StrPtr = ConfigString + 5 + 32 + 6;
1107     while (*StrPtr != L'\0' && *StrPtr != L'&') {
1108       StrPtr++;
1109     }
1110     if (*StrPtr != L'&') {
1111       return FALSE;
1112     }
1113
1114     *StrPtr = L'\0';
1115     BufferSize = (((UINTN) StrPtr) - ((UINTN) &ConfigString[5 + 32 + 6])) / 4 + sizeof (CHAR16);
1116     Name = AllocatePool (BufferSize);
1117     ASSERT (Name != NULL);
1118     Status = ConfigStringToUnicode (
1119                Name,
1120                &BufferSize,
1121                ConfigString + 5 + 32 + 6
1122                );
1123     *StrPtr = L'&';
1124
1125     if (EFI_ERROR (Status) || (StrCmp (Name, StorageName) != 0)) {
1126       Match = FALSE;
1127     }
1128     FreePool (Name);
1129   }
1130
1131   return Match;
1132 }
1133
1134 /**
1135   Search BlockName "&OFFSET=Offset&WIDTH=Width" in a string.
1136
1137   @param  String                 The string to be searched in.
1138   @param  Offset                 Offset in BlockName.
1139   @param  Width                  Width in BlockName.
1140
1141   @retval TRUE                   Block name found.
1142   @retval FALSE                  Block name not found.
1143
1144 **/
1145 BOOLEAN
1146 EFIAPI
1147 FindBlockName (
1148   IN OUT CHAR16                *String,
1149   IN UINTN                     Offset,
1150   IN UINTN                     Width
1151   )
1152 {
1153   EFI_STATUS  Status;
1154   UINTN       Data;
1155   UINTN       BufferSize;
1156   UINTN       ConvertedStrLen;
1157
1158   while ((String = StrStr (String, L"&OFFSET=")) != NULL) {
1159     //
1160     // Skip '&OFFSET='
1161     //
1162     String = String + 8;
1163
1164     Data = 0;
1165     BufferSize = sizeof (UINTN);
1166     Status = HexStringToBuf ((UINT8 *) &Data, &BufferSize, String, &ConvertedStrLen);
1167     if (EFI_ERROR (Status)) {
1168       return FALSE;
1169     }
1170     String = String + ConvertedStrLen;
1171
1172     if (Data != Offset) {
1173       continue;
1174     }
1175
1176     if (StrnCmp (String, L"&WIDTH=", 7) != 0) {
1177       return FALSE;
1178     }
1179     String = String + 7;
1180
1181     Data = 0;
1182     BufferSize = sizeof (UINTN);
1183     Status = HexStringToBuf ((UINT8 *) &Data, &BufferSize, String, &ConvertedStrLen);
1184     if (EFI_ERROR (Status)) {
1185       return FALSE;
1186     }
1187     if (Data == Width) {
1188       return TRUE;
1189     }
1190
1191     String = String + ConvertedStrLen;
1192   }
1193
1194   return FALSE;
1195 }
1196
1197
1198 /**
1199   This routine is invoked by ConfigAccess.Callback() to retrived uncommitted data from Form Browser.
1200
1201   @param  VariableGuid           An optional field to indicate the target variable
1202                                  GUID name to use.
1203   @param  VariableName           An optional field to indicate the target
1204                                  human-readable variable name.
1205   @param  BufferSize             On input: Length in bytes of buffer to hold
1206                                  retrived data. On output: If return
1207                                  EFI_BUFFER_TOO_SMALL, containg length of buffer
1208                                  desired.
1209   @param  Buffer                 Buffer to hold retrived data.
1210
1211   @retval EFI_SUCCESS            Operation completes successfully.
1212   @retval EFI_BUFFER_TOO_SMALL   The intput buffer is too small.
1213   @retval EFI_OUT_OF_RESOURCES   There is no enough available memory space.
1214
1215 **/
1216 EFI_STATUS
1217 EFIAPI
1218 GetBrowserData (
1219   IN CONST EFI_GUID              *VariableGuid, OPTIONAL
1220   IN CONST CHAR16                *VariableName, OPTIONAL
1221   IN OUT UINTN                   *BufferSize,
1222   IN OUT UINT8                   *Buffer
1223   )
1224 {
1225   EFI_STATUS                      Status;
1226   CONST CHAR16                    *ConfigHdr;
1227   CHAR16                          *ConfigResp;
1228   CHAR16                          *StringPtr;
1229   UINTN                           HeaderLen;
1230   UINTN                           BufferLen;
1231   CHAR16                          *Progress;
1232
1233   //
1234   // Locate protocols for use
1235   //
1236   Status = LocateFormBrowser2Protocols ();
1237   if (EFI_ERROR (Status)) {
1238     return Status;
1239   }
1240
1241   //
1242   // Retrive formset storage data from Form Browser
1243   //
1244   ConfigHdr = mFakeConfigHdr;
1245   HeaderLen = StrLen (ConfigHdr);
1246
1247   //
1248   // First try allocate 0x4000 buffer for the formet storage data.
1249   //
1250   BufferLen = 0x4000;
1251   ConfigResp = AllocateZeroPool (BufferLen + HeaderLen);
1252   if (ConfigResp == NULL) {
1253     return EFI_OUT_OF_RESOURCES;
1254   }
1255
1256   StringPtr = ConfigResp + HeaderLen;
1257   *StringPtr = L'&';
1258   StringPtr++;
1259
1260   Status = mFormBrowser2->BrowserCallback (
1261                            mFormBrowser2,
1262                            &BufferLen,
1263                            StringPtr,
1264                            TRUE,
1265                            VariableGuid,
1266                            VariableName
1267                            );
1268   if (Status == EFI_BUFFER_TOO_SMALL) {
1269     FreePool (ConfigResp);
1270
1271     ConfigResp = AllocateZeroPool (BufferLen + HeaderLen);
1272     if (ConfigResp == NULL) {
1273       return EFI_OUT_OF_RESOURCES;
1274     }
1275
1276     StringPtr = ConfigResp + HeaderLen;
1277     *StringPtr = L'&';
1278     StringPtr++;
1279
1280     Status = mFormBrowser2->BrowserCallback (
1281                              mFormBrowser2,
1282                              &BufferLen,
1283                              StringPtr,
1284                              TRUE,
1285                              VariableGuid,
1286                              VariableName
1287                              );
1288   }
1289   if (EFI_ERROR (Status)) {
1290     FreePool (ConfigResp);
1291     return Status;
1292   }
1293   CopyMem (ConfigResp, ConfigHdr, HeaderLen * sizeof (UINT16));
1294
1295   //
1296   // Convert <ConfigResp> to buffer data
1297   //
1298   Status = mIfrSupportLibHiiConfigRouting->ConfigToBlock (
1299                                mIfrSupportLibHiiConfigRouting,
1300                                ConfigResp,
1301                                Buffer,
1302                                BufferSize,
1303                                &Progress
1304                                );
1305   FreePool (ConfigResp);
1306
1307   return Status;
1308 }
1309
1310
1311 /**
1312   This routine is invoked by ConfigAccess.Callback() to update uncommitted data of Form Browser.
1313
1314   @param  VariableGuid           An optional field to indicate the target variable
1315                                  GUID name to use.
1316   @param  VariableName           An optional field to indicate the target
1317                                  human-readable variable name.
1318   @param  BufferSize             Length in bytes of buffer to hold retrived data.
1319   @param  Buffer                 Buffer to hold retrived data.
1320   @param  RequestElement         An optional field to specify which part of the
1321                                  buffer data will be send back to Browser. If NULL,
1322                                  the whole buffer of data will be committed to
1323                                  Browser. <RequestElement> ::=
1324                                  &OFFSET=<Number>&WIDTH=<Number>*
1325
1326   @retval EFI_SUCCESS            Operation completes successfully.
1327   @retval EFI_OUT_OF_RESOURCES   There is no enough available memory space.
1328   @retval Other                  Updating Browser uncommitted data failed.
1329
1330 **/
1331 EFI_STATUS
1332 EFIAPI
1333 SetBrowserData (
1334   IN CONST EFI_GUID          *VariableGuid, OPTIONAL
1335   IN CONST CHAR16            *VariableName, OPTIONAL
1336   IN UINTN                   BufferSize,
1337   IN CONST UINT8             *Buffer,
1338   IN CONST CHAR16            *RequestElement  OPTIONAL
1339   )
1340 {
1341   EFI_STATUS                      Status;
1342   CONST CHAR16                    *ConfigHdr;
1343   CHAR16                          *ConfigResp;
1344   CHAR16                          *StringPtr;
1345   UINTN                           HeaderLen;
1346   UINTN                           BufferLen;
1347   CHAR16                          *Progress;
1348   CHAR16                          BlockName[33];
1349   CHAR16                          *ConfigRequest;
1350   CONST CHAR16                    *Request;
1351
1352   //
1353   // Locate protocols for use
1354   //
1355   Status = LocateFormBrowser2Protocols ();
1356   if (EFI_ERROR (Status)) {
1357     return Status;
1358   }
1359
1360   //
1361   // Prepare <ConfigRequest>
1362   //
1363   ConfigHdr = mFakeConfigHdr;
1364   HeaderLen = StrLen (ConfigHdr);
1365
1366   if (RequestElement == NULL) {
1367     //
1368     // RequestElement not specified, use "&OFFSET=0&WIDTH=<BufferSize>" as <BlockName>
1369     //
1370     BlockName[0] = L'\0';
1371     StrCpy (BlockName, L"&OFFSET=0&WIDTH=");
1372
1373     //
1374     // String lenghth of L"&OFFSET=0&WIDTH=" is 16
1375     //
1376     StringPtr = BlockName + 16;
1377     BufferLen = sizeof (BlockName) - (16 * sizeof (CHAR16));
1378     BufToHexString (StringPtr, &BufferLen, (UINT8 *) &BufferSize, sizeof (UINTN));
1379
1380     Request = BlockName;
1381   } else {
1382     Request = RequestElement;
1383   }
1384
1385   BufferLen = HeaderLen * sizeof (CHAR16) + StrSize (Request);
1386   ConfigRequest = AllocateZeroPool (BufferLen);
1387   if (ConfigRequest == NULL) {
1388     return EFI_OUT_OF_RESOURCES;
1389   }
1390
1391   CopyMem (ConfigRequest, ConfigHdr, HeaderLen * sizeof (CHAR16));
1392   StringPtr = ConfigRequest + HeaderLen;
1393   StrCpy (StringPtr, Request);
1394
1395   //
1396   // Convert buffer to <ConfigResp>
1397   //
1398   Status = mIfrSupportLibHiiConfigRouting->BlockToConfig (
1399                                 mIfrSupportLibHiiConfigRouting,
1400                                 ConfigRequest,
1401                                 Buffer,
1402                                 BufferSize,
1403                                 &ConfigResp,
1404                                 &Progress
1405                                 );
1406   if (EFI_ERROR (Status)) {
1407     FreePool (ConfigRequest);
1408     return Status;
1409   }
1410
1411   //
1412   // Skip <ConfigHdr> and '&'
1413   //
1414   StringPtr = ConfigResp + HeaderLen + 1;
1415
1416   //
1417   // Change uncommitted data in Browser
1418   //
1419   Status = mFormBrowser2->BrowserCallback (
1420                            mFormBrowser2,
1421                            &BufferSize,
1422                            StringPtr,
1423                            FALSE,
1424                            VariableGuid,
1425                            VariableName
1426                            );
1427   FreePool (ConfigRequest);
1428   return Status;
1429 }
1430
1431 /**
1432   Test if  a Unicode character is a hexadecimal digit. If true, the input
1433   Unicode character is converted to a byte.
1434
1435   This function tests if a Unicode character is a hexadecimal digit. If true, the input
1436   Unicode character is converted to a byte. For example, Unicode character
1437   L'A' will be converted to 0x0A.
1438
1439   If Digit is NULL, then ASSERT.
1440
1441   @param  Digit       The output hexadecimal digit.
1442
1443   @param  Char        The input Unicode character.
1444
1445   @retval TRUE        Char is in the range of Hexadecimal number. Digit is updated
1446                       to the byte value of the number.
1447   @retval FALSE       Char is not in the range of Hexadecimal number. Digit is keep
1448                       intact.
1449
1450 **/
1451 BOOLEAN
1452 EFIAPI
1453 IsHexDigit (
1454   OUT UINT8      *Digit,
1455   IN  CHAR16      Char
1456   )
1457 {
1458   ASSERT (Digit != NULL);
1459
1460   if ((Char >= L'0') && (Char <= L'9')) {
1461     *Digit = (UINT8) (Char - L'0');
1462     return TRUE;
1463   }
1464
1465   if ((Char >= L'A') && (Char <= L'F')) {
1466     *Digit = (UINT8) (Char - L'A' + 0x0A);
1467     return TRUE;
1468   }
1469
1470   if ((Char >= L'a') && (Char <= L'f')) {
1471     *Digit = (UINT8) (Char - L'a' + 0x0A);
1472     return TRUE;
1473   }
1474
1475   return FALSE;
1476 }
1477
1478 /**
1479   Convert binary buffer to a Unicode String in a specified sequence.
1480
1481   This function converts bytes in the memory block pointed by Buffer to a Unicode String Str.
1482   Each byte will be represented by two Unicode characters. For example, byte 0xA1 will
1483   be converted into two Unicode character L'A' and L'1'. In the output String, the Unicode Character
1484   for the Most Significant Nibble will be put before the Unicode Character for the Least Significant
1485   Nibble. The output string for the buffer containing a single byte 0xA1 will be L"A1".
1486   For a buffer with multiple bytes, the Unicode character produced by the first byte will be put into the
1487   the last character in the output string. The one next to first byte will be put into the
1488   character before the last character. This rules applies to the rest of the bytes. The Unicode
1489   character by the last byte will be put into the first character in the output string. For example,
1490   the input buffer for a 64-bits unsigned integer 0x12345678abcdef1234 will be converted to
1491   a Unicode string equal to L"12345678abcdef1234".
1492
1493   @param String                        On input, String is pointed to the buffer allocated for the convertion.
1494   @param StringLen                     The Length of String buffer to hold the output String. The length must include the tailing '\0' character.
1495                                        The StringLen required to convert a N bytes Buffer will be a least equal to or greater
1496                                        than 2*N + 1.
1497   @param Buffer                        The pointer to a input buffer.
1498   @param BufferSizeInBytes             Length in bytes of the input buffer.
1499
1500
1501   @retval  EFI_SUCCESS                 The convertion is successful. All bytes in Buffer has been convert to the corresponding
1502                                        Unicode character and placed into the right place in String.
1503   @retval  EFI_BUFFER_TOO_SMALL        StringSizeInBytes is smaller than 2 * N + 1the number of bytes required to
1504                                        complete the convertion.
1505 **/
1506 RETURN_STATUS
1507 EFIAPI
1508 BufToHexString (
1509   IN OUT       CHAR16               *String,
1510   IN OUT       UINTN                *StringLen,
1511   IN     CONST UINT8                *Buffer,
1512   IN           UINTN                BufferSizeInBytes
1513   )
1514 {
1515   UINTN       Idx;
1516   UINT8       Byte;
1517   UINTN       StrLen;
1518
1519   //
1520   // Make sure string is either passed or allocate enough.
1521   // It takes 2 Unicode characters (4 bytes) to represent 1 byte of the binary buffer.
1522   // Plus the Unicode termination character.
1523   //
1524   StrLen = BufferSizeInBytes * 2;
1525   if (StrLen > ((*StringLen) - 1)) {
1526     *StringLen = StrLen + 1;
1527     return RETURN_BUFFER_TOO_SMALL;
1528   }
1529
1530   *StringLen = StrLen + 1;
1531   //
1532   // Ends the string.
1533   //
1534   String[StrLen] = L'\0';
1535
1536   for (Idx = 0; Idx < BufferSizeInBytes; Idx++) {
1537     Byte = Buffer[Idx];
1538     String[StrLen - 1 - Idx * 2] = mIfrSupportLibHexStr [Byte & 0xF];
1539     String[StrLen - 2 - Idx * 2] = mIfrSupportLibHexStr [Byte >> 4];
1540   }
1541
1542   return RETURN_SUCCESS;
1543 }
1544
1545
1546 /**
1547   Convert a Unicode string consisting of hexadecimal characters to a output byte buffer.
1548
1549   This function converts a Unicode string consisting of characters in the range of Hexadecimal
1550   character (L'0' to L'9', L'A' to L'F' and L'a' to L'f') to a output byte buffer. The function will stop
1551   at the first non-hexadecimal character or the NULL character. The convertion process can be
1552   simply viewed as the reverse operations defined by BufToHexString. Two Unicode characters will be
1553   converted into one byte. The first Unicode character represents the Most Significant Nibble and the
1554   second Unicode character represents the Least Significant Nibble in the output byte.
1555   The first pair of Unicode characters represents the last byte in the output buffer. The second pair of Unicode
1556   characters represent the  the byte preceding the last byte. This rule applies to the rest pairs of bytes.
1557   The last pair represent the first byte in the output buffer.
1558
1559   For example, a Unciode String L"12345678" will be converted into a buffer wil the following bytes
1560   (first byte is the byte in the lowest memory address): "0x78, 0x56, 0x34, 0x12".
1561
1562   If String has N valid hexadecimal characters for conversion,  the caller must make sure Buffer is at least
1563   N/2 (if N is even) or (N+1)/2 (if N if odd) bytes.
1564
1565   @param Buffer                      The output buffer allocated by the caller.
1566   @param BufferSizeInBytes           On input, the size in bytes of Buffer. On output, it is updated to
1567                                      contain the size of the Buffer which is actually used for the converstion.
1568                                      For Unicode string with 2*N hexadecimal characters (not including the
1569                                      tailing NULL character), N bytes of Buffer will be used for the output.
1570   @param String                      The input hexadecimal string.
1571   @param ConvertedStrLen             The number of hexadecimal characters used to produce content in output
1572                                      buffer Buffer.
1573
1574   @retval  RETURN_BUFFER_TOO_SMALL   The input BufferSizeInBytes is too small to hold the output. BufferSizeInBytes
1575                                      will be updated to the size required for the converstion.
1576   @retval  RETURN_SUCCESS            The convertion is successful or the first Unicode character from String
1577                                      is hexadecimal. If ConvertedStrLen is not NULL, it is updated
1578                                      to the number of hexadecimal character used for the converstion.
1579 **/
1580 RETURN_STATUS
1581 EFIAPI
1582 HexStringToBuf (
1583   OUT          UINT8                    *Buffer,
1584   IN OUT       UINTN                    *BufferSizeInBytes,
1585   IN     CONST CHAR16                   *String,
1586   OUT          UINTN                    *ConvertedStrLen  OPTIONAL
1587   )
1588 {
1589   UINTN       HexCnt;
1590   UINTN       Idx;
1591   UINTN       BufferLength;
1592   UINT8       Digit;
1593   UINT8       Byte;
1594
1595   //
1596   // Find out how many hex characters the string has.
1597   //
1598   for (Idx = 0, HexCnt = 0; IsHexDigit (&Digit, String[Idx]); Idx++, HexCnt++);
1599
1600   if (HexCnt == 0) {
1601     *ConvertedStrLen = 0;
1602     return RETURN_SUCCESS;
1603   }
1604   //
1605   // Two Unicode characters make up 1 buffer byte. Round up.
1606   //
1607   BufferLength = (HexCnt + 1) / 2;
1608
1609   //
1610   // Test if  buffer is passed enough.
1611   //
1612   if (BufferLength > (*BufferSizeInBytes)) {
1613     *BufferSizeInBytes = BufferLength;
1614     return RETURN_BUFFER_TOO_SMALL;
1615   }
1616
1617   *BufferSizeInBytes = BufferLength;
1618
1619   for (Idx = 0; Idx < HexCnt; Idx++) {
1620
1621     IsHexDigit (&Digit, String[HexCnt - 1 - Idx]);
1622
1623     //
1624     // For odd charaters, write the lower nibble for each buffer byte,
1625     // and for even characters, the upper nibble.
1626     //
1627     if ((Idx & 1) == 0) {
1628       Byte = Digit;
1629     } else {
1630       Byte = Buffer[Idx / 2];
1631       Byte &= 0x0F;
1632       Byte = (UINT8) (Byte | Digit << 4);
1633     }
1634
1635     Buffer[Idx / 2] = Byte;
1636   }
1637
1638   if (ConvertedStrLen != NULL) {
1639     *ConvertedStrLen = HexCnt;
1640   }
1641
1642   return RETURN_SUCCESS;
1643 }