MdeModulePkg/Universal/DriverSampleDxe/DriverSample.c

   1 /** @file
   2 This is an example of how a driver might export data to the HII protocol to be
   3 later utilized by the Setup Protocol
   4
   5 Copyright (c) 2004 - 2015, Intel Corporation. All rights reserved.<BR>
   6 This program and the accompanying materials
   7 are licensed and made available under the terms and conditions of the BSD License
   8 which accompanies this distribution.  The full text of the license may be found at
   9 http://opensource.org/licenses/bsd-license.php
  10
  11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16
  17 #include "DriverSample.h"
  18
  19 #define DISPLAY_ONLY_MY_ITEM  0x0002
  20
  21 CHAR16     VariableName[] = L"MyIfrNVData";
  22 CHAR16     MyEfiVar[] = L"MyEfiVar";
  23 EFI_HANDLE                      DriverHandle[2] = {NULL, NULL};
  24 DRIVER_SAMPLE_PRIVATE_DATA      *PrivateData = NULL;
  25 EFI_EVENT                       mEvent;
  26
  27 HII_VENDOR_DEVICE_PATH  mHiiVendorDevicePath0 = {
  28   {
  29     {
  30       HARDWARE_DEVICE_PATH,
  31       HW_VENDOR_DP,
  32       {
  33         (UINT8) (sizeof (VENDOR_DEVICE_PATH)),
  34         (UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8)
  35       }
  36     },
  37     DRIVER_SAMPLE_FORMSET_GUID
  38   },
  39   {
  40     END_DEVICE_PATH_TYPE,
  41     END_ENTIRE_DEVICE_PATH_SUBTYPE,
  42     {
  43       (UINT8) (END_DEVICE_PATH_LENGTH),
  44       (UINT8) ((END_DEVICE_PATH_LENGTH) >> 8)
  45     }
  46   }
  47 };
  48
  49 HII_VENDOR_DEVICE_PATH  mHiiVendorDevicePath1 = {
  50   {
  51     {
  52       HARDWARE_DEVICE_PATH,
  53       HW_VENDOR_DP,
  54       {
  55         (UINT8) (sizeof (VENDOR_DEVICE_PATH)),
  56         (UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8)
  57       }
  58     },
  59     DRIVER_SAMPLE_INVENTORY_GUID
  60   },
  61   {
  62     END_DEVICE_PATH_TYPE,
  63     END_ENTIRE_DEVICE_PATH_SUBTYPE,
  64     {
  65       (UINT8) (END_DEVICE_PATH_LENGTH),
  66       (UINT8) ((END_DEVICE_PATH_LENGTH) >> 8)
  67     }
  68   }
  69 };
  70
  71 /**
  72   Add empty function for event process function.
  73
  74   @param Event    The Event need to be process
  75   @param Context  The context of the event.
  76
  77 **/
  78 VOID
  79 EFIAPI
  80 DriverSampleInternalEmptyFunction (
  81   IN  EFI_EVENT Event,
  82   IN  VOID      *Context
  83   )
  84 {
  85 }
  86
  87 /**
  88   Notification function for keystrokes.
  89
  90   @param[in] KeyData    The key that was pressed.
  91
  92   @retval EFI_SUCCESS   The operation was successful.
  93 **/
  94 EFI_STATUS
  95 EFIAPI
  96 NotificationFunction(
  97   IN EFI_KEY_DATA *KeyData
  98   )
  99 {
 100   gBS->SignalEvent (mEvent);
 101
 102   return EFI_SUCCESS;
 103 }
 104
 105 /**
 106   Function to start monitoring for CTRL-C using SimpleTextInputEx.
 107
 108   @retval EFI_SUCCESS           The feature is enabled.
 109   @retval EFI_OUT_OF_RESOURCES  There is not enough mnemory available.
 110 **/
 111 EFI_STATUS
 112 EFIAPI
 113 InternalStartMonitor(
 114   VOID
 115   )
 116 {
 117   EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *SimpleEx;
 118   EFI_KEY_DATA                      KeyData;
 119   EFI_STATUS                        Status;
 120   EFI_HANDLE                        *Handles;
 121   UINTN                             HandleCount;
 122   UINTN                             HandleIndex;
 123   EFI_HANDLE                        NotifyHandle;
 124
 125   Status = gBS->LocateHandleBuffer (
 126               ByProtocol,
 127               &gEfiSimpleTextInputExProtocolGuid,
 128               NULL,
 129               &HandleCount,
 130               &Handles
 131               );
 132   for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++) {
 133     Status = gBS->HandleProtocol (Handles[HandleIndex], &gEfiSimpleTextInputExProtocolGuid, (VOID **) &SimpleEx);
 134     ASSERT_EFI_ERROR (Status);
 135
 136     KeyData.KeyState.KeyToggleState = 0;
 137     KeyData.Key.ScanCode            = 0;
 138     KeyData.KeyState.KeyShiftState  = EFI_SHIFT_STATE_VALID|EFI_LEFT_CONTROL_PRESSED;
 139     KeyData.Key.UnicodeChar         = L'c';
 140
 141     Status = SimpleEx->RegisterKeyNotify(
 142       SimpleEx,
 143       &KeyData,
 144       NotificationFunction,
 145       &NotifyHandle);
 146     if (EFI_ERROR (Status)) {
 147       break;
 148     }
 149
 150     KeyData.KeyState.KeyShiftState  = EFI_SHIFT_STATE_VALID|EFI_RIGHT_CONTROL_PRESSED;
 151     Status = SimpleEx->RegisterKeyNotify(
 152       SimpleEx,
 153       &KeyData,
 154       NotificationFunction,
 155       &NotifyHandle);
 156     if (EFI_ERROR (Status)) {
 157       break;
 158     }
 159   }
 160
 161   return EFI_SUCCESS;
 162 }
 163
 164 /**
 165   Function to stop monitoring for CTRL-C using SimpleTextInputEx.
 166
 167   @retval EFI_SUCCESS           The feature is enabled.
 168   @retval EFI_OUT_OF_RESOURCES  There is not enough mnemory available.
 169 **/
 170 EFI_STATUS
 171 EFIAPI
 172 InternalStopMonitor(
 173   VOID
 174   )
 175 {
 176   EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *SimpleEx;
 177   EFI_STATUS                        Status;
 178   EFI_HANDLE                        *Handles;
 179   EFI_KEY_DATA                      KeyData;
 180   UINTN                             HandleCount;
 181   UINTN                             HandleIndex;
 182   EFI_HANDLE                        NotifyHandle;
 183
 184   Status = gBS->LocateHandleBuffer (
 185                 ByProtocol,
 186                 &gEfiSimpleTextInputExProtocolGuid,
 187                 NULL,
 188                 &HandleCount,
 189                 &Handles
 190                 );
 191   for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++) {
 192     Status = gBS->HandleProtocol (Handles[HandleIndex], &gEfiSimpleTextInputExProtocolGuid, (VOID **) &SimpleEx);
 193     ASSERT_EFI_ERROR (Status);
 194
 195     KeyData.KeyState.KeyToggleState = 0;
 196     KeyData.Key.ScanCode            = 0;
 197     KeyData.KeyState.KeyShiftState  = EFI_SHIFT_STATE_VALID|EFI_LEFT_CONTROL_PRESSED;
 198     KeyData.Key.UnicodeChar         = L'c';
 199
 200     Status = SimpleEx->RegisterKeyNotify(
 201       SimpleEx,
 202       &KeyData,
 203       NotificationFunction,
 204       &NotifyHandle);
 205     if (!EFI_ERROR (Status)) {
 206       Status = SimpleEx->UnregisterKeyNotify (SimpleEx, NotifyHandle);
 207     }
 208
 209     KeyData.KeyState.KeyShiftState  = EFI_SHIFT_STATE_VALID|EFI_RIGHT_CONTROL_PRESSED;
 210     Status = SimpleEx->RegisterKeyNotify(
 211       SimpleEx,
 212       &KeyData,
 213       NotificationFunction,
 214       &NotifyHandle);
 215     if (!EFI_ERROR (Status)) {
 216       Status = SimpleEx->UnregisterKeyNotify (SimpleEx, NotifyHandle);
 217     }
 218   }
 219   return EFI_SUCCESS;
 220 }
 221
 222
 223 /**
 224   Encode the password using a simple algorithm.
 225
 226   @param Password The string to be encoded.
 227   @param MaxSize  The size of the string.
 228
 229 **/
 230 VOID
 231 EncodePassword (
 232   IN  CHAR16                      *Password,
 233   IN  UINTN                       MaxSize
 234   )
 235 {
 236   UINTN   Index;
 237   UINTN   Loop;
 238   CHAR16  *Buffer;
 239   CHAR16  *Key;
 240
 241   Key     = L"MAR10648567";
 242   Buffer  = AllocateZeroPool (MaxSize);
 243   ASSERT (Buffer != NULL);
 244
 245   for (Index = 0; Key[Index] != 0; Index++) {
 246     for (Loop = 0; Loop < (UINT8) (MaxSize / 2); Loop++) {
 247       Buffer[Loop] = (CHAR16) (Password[Loop] ^ Key[Index]);
 248     }
 249   }
 250
 251   CopyMem (Password, Buffer, MaxSize);
 252
 253   FreePool (Buffer);
 254   return ;
 255 }
 256
 257 /**
 258   Validate the user's password.
 259
 260   @param PrivateData This driver's private context data.
 261   @param StringId    The user's input.
 262
 263   @retval EFI_SUCCESS   The user's input matches the password.
 264   @retval EFI_NOT_READY The user's input does not match the password.
 265 **/
 266 EFI_STATUS
 267 ValidatePassword (
 268   IN       DRIVER_SAMPLE_PRIVATE_DATA      *PrivateData,
 269   IN       EFI_STRING_ID                   StringId
 270   )
 271 {
 272   EFI_STATUS                      Status;
 273   UINTN                           Index;
 274   UINTN                           BufferSize;
 275   UINTN                           PasswordMaxSize;
 276   CHAR16                          *Password;
 277   CHAR16                          *EncodedPassword;
 278   BOOLEAN                         OldPassword;
 279
 280   //
 281   // Get encoded password first
 282   //
 283   BufferSize = sizeof (DRIVER_SAMPLE_CONFIGURATION);
 284   Status = gRT->GetVariable (
 285                   VariableName,
 286                   &gDriverSampleFormSetGuid,
 287                   NULL,
 288                   &BufferSize,
 289                   &PrivateData->Configuration
 290                   );
 291   if (EFI_ERROR (Status)) {
 292     //
 293     // Old password not exist, prompt for new password
 294     //
 295     return EFI_SUCCESS;
 296   }
 297
 298   OldPassword = FALSE;
 299   PasswordMaxSize = sizeof (PrivateData->Configuration.WhatIsThePassword2);
 300   //
 301   // Check whether we have any old password set
 302   //
 303   for (Index = 0; Index < PasswordMaxSize / sizeof (UINT16); Index++) {
 304     if (PrivateData->Configuration.WhatIsThePassword2[Index] != 0) {
 305       OldPassword = TRUE;
 306       break;
 307     }
 308   }
 309   if (!OldPassword) {
 310     //
 311     // Old password not exist, return EFI_SUCCESS to prompt for new password
 312     //
 313     return EFI_SUCCESS;
 314   }
 315
 316   //
 317   // Get user input password
 318   //
 319   Password = HiiGetString (PrivateData->HiiHandle[0], StringId, NULL);
 320   if (Password == NULL) {
 321     return EFI_NOT_READY;
 322   }
 323   if (StrSize (Password) > PasswordMaxSize) {
 324     FreePool (Password);
 325     return EFI_NOT_READY;
 326   }
 327
 328   //
 329   // Validate old password
 330   //
 331   EncodedPassword = AllocateZeroPool (PasswordMaxSize);
 332   ASSERT (EncodedPassword != NULL);
 333   StrnCpyS (EncodedPassword, PasswordMaxSize / sizeof (CHAR16), Password, StrLen (Password));
 334   EncodePassword (EncodedPassword, StrLen (EncodedPassword) * sizeof (CHAR16));
 335   if (CompareMem (EncodedPassword, PrivateData->Configuration.WhatIsThePassword2, PasswordMaxSize) != 0) {
 336     //
 337     // Old password mismatch, return EFI_NOT_READY to prompt for error message
 338     //
 339     Status = EFI_NOT_READY;
 340   } else {
 341     Status = EFI_SUCCESS;
 342   }
 343
 344   FreePool (Password);
 345   FreePool (EncodedPassword);
 346
 347   return Status;
 348 }
 349
 350 /**
 351   Encode the password using a simple algorithm.
 352
 353   @param PrivateData This driver's private context data.
 354   @param StringId    The password from User.
 355
 356   @retval  EFI_SUCESS The operation is successful.
 357   @return  Other value if gRT->SetVariable () fails.
 358
 359 **/
 360 EFI_STATUS
 361 SetPassword (
 362   IN DRIVER_SAMPLE_PRIVATE_DATA      *PrivateData,
 363   IN EFI_STRING_ID                   StringId
 364   )
 365 {
 366   EFI_STATUS                      Status;
 367   CHAR16                          *Password;
 368   CHAR16                          *TempPassword;
 369   UINTN                           PasswordSize;
 370   DRIVER_SAMPLE_CONFIGURATION     *Configuration;
 371   UINTN                           BufferSize;
 372
 373   //
 374   // Get Buffer Storage data from EFI variable
 375   //
 376   BufferSize = sizeof (DRIVER_SAMPLE_CONFIGURATION);
 377   Status = gRT->GetVariable (
 378                   VariableName,
 379                   &gDriverSampleFormSetGuid,
 380                   NULL,
 381                   &BufferSize,
 382                   &PrivateData->Configuration
 383                   );
 384   if (EFI_ERROR (Status)) {
 385     return Status;
 386   }
 387
 388   //
 389   // Get user input password
 390   //
 391   Password = PrivateData->Configuration.WhatIsThePassword2;
 392   PasswordSize = sizeof (PrivateData->Configuration.WhatIsThePassword2);
 393   ZeroMem (Password, PasswordSize);
 394
 395   TempPassword = HiiGetString (PrivateData->HiiHandle[0], StringId, NULL);
 396   if (TempPassword == NULL) {
 397     return EFI_NOT_READY;
 398   }
 399   if (StrSize (TempPassword) > PasswordSize) {
 400     FreePool (TempPassword);
 401     return EFI_NOT_READY;
 402   }
 403   StrnCpyS (Password, PasswordSize / sizeof (CHAR16), TempPassword, StrLen (TempPassword));
 404   FreePool (TempPassword);
 405
 406   //
 407   // Retrive uncommitted data from Browser
 408   //
 409   Configuration = AllocateZeroPool (sizeof (DRIVER_SAMPLE_CONFIGURATION));
 410   ASSERT (Configuration != NULL);
 411   if (HiiGetBrowserData (&gDriverSampleFormSetGuid, VariableName, sizeof (DRIVER_SAMPLE_CONFIGURATION), (UINT8 *) Configuration)) {
 412     //
 413     // Update password's clear text in the screen
 414     //
 415     CopyMem (Configuration->PasswordClearText, Password, StrSize (Password));
 416
 417     //
 418     // Update uncommitted data of Browser
 419     //
 420     HiiSetBrowserData (
 421        &gDriverSampleFormSetGuid,
 422        VariableName,
 423        sizeof (DRIVER_SAMPLE_CONFIGURATION),
 424        (UINT8 *) Configuration,
 425        NULL
 426        );
 427   }
 428
 429   //
 430   // Free Configuration Buffer
 431   //
 432   FreePool (Configuration);
 433
 434
 435   //
 436   // Set password
 437   //
 438   EncodePassword (Password, StrLen (Password) * 2);
 439   Status = gRT->SetVariable(
 440                   VariableName,
 441                   &gDriverSampleFormSetGuid,
 442                   EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
 443                   sizeof (DRIVER_SAMPLE_CONFIGURATION),
 444                   &PrivateData->Configuration
 445                   );
 446   return Status;
 447 }
 448
 449 /**
 450  Update names of Name/Value storage to current language.
 451
 452  @param PrivateData   Points to the driver private data.
 453
 454  @retval EFI_SUCCESS   All names are successfully updated.
 455  @retval EFI_NOT_FOUND Failed to get Name from HII database.
 456
 457 **/
 458 EFI_STATUS
 459 LoadNameValueNames (
 460   IN DRIVER_SAMPLE_PRIVATE_DATA      *PrivateData
 461   )
 462 {
 463   UINTN      Index;
 464
 465   //
 466   // Get Name/Value name string of current language
 467   //
 468   for (Index = 0; Index < NAME_VALUE_NAME_NUMBER; Index++) {
 469     PrivateData->NameValueName[Index] = HiiGetString (
 470                                          PrivateData->HiiHandle[0],
 471                                          PrivateData->NameStringId[Index],
 472                                          NULL
 473                                          );
 474     if (PrivateData->NameValueName[Index] == NULL) {
 475       return EFI_NOT_FOUND;
 476     }
 477   }
 478
 479   return EFI_SUCCESS;
 480 }
 481
 482
 483 /**
 484   Get the value of <Number> in <BlockConfig> format, i.e. the value of OFFSET
 485   or WIDTH or VALUE.
 486   <BlockConfig> ::= 'OFFSET='<Number>&'WIDTH='<Number>&'VALUE'=<Number>
 487
 488   This is a internal function.
 489
 490   @param  StringPtr              String in <BlockConfig> format and points to the
 491                                  first character of <Number>.
 492   @param  Number                 The output value. Caller takes the responsibility
 493                                  to free memory.
 494   @param  Len                    Length of the <Number>, in characters.
 495
 496   @retval EFI_OUT_OF_RESOURCES   Insufficient resources to store neccessary
 497                                  structures.
 498   @retval EFI_SUCCESS            Value of <Number> is outputted in Number
 499                                  successfully.
 500
 501 **/
 502 EFI_STATUS
 503 GetValueOfNumber (
 504   IN EFI_STRING                    StringPtr,
 505   OUT UINT8                        **Number,
 506   OUT UINTN                        *Len
 507   )
 508 {
 509   EFI_STRING               TmpPtr;
 510   UINTN                    Length;
 511   EFI_STRING               Str;
 512   UINT8                    *Buf;
 513   EFI_STATUS               Status;
 514   UINT8                    DigitUint8;
 515   UINTN                    Index;
 516   CHAR16                   TemStr[2];
 517
 518   if (StringPtr == NULL || *StringPtr == L'\0' || Number == NULL || Len == NULL) {
 519     return EFI_INVALID_PARAMETER;
 520   }
 521
 522   Buf = NULL;
 523
 524   TmpPtr = StringPtr;
 525   while (*StringPtr != L'\0' && *StringPtr != L'&') {
 526     StringPtr++;
 527   }
 528   *Len   = StringPtr - TmpPtr;
 529   Length = *Len + 1;
 530
 531   Str = (EFI_STRING) AllocateZeroPool (Length * sizeof (CHAR16));
 532   if (Str == NULL) {
 533     Status = EFI_OUT_OF_RESOURCES;
 534     goto Exit;
 535   }
 536   CopyMem (Str, TmpPtr, *Len * sizeof (CHAR16));
 537   *(Str + *Len) = L'\0';
 538
 539   Length = (Length + 1) / 2;
 540   Buf = (UINT8 *) AllocateZeroPool (Length);
 541   if (Buf == NULL) {
 542     Status = EFI_OUT_OF_RESOURCES;
 543     goto Exit;
 544   }
 545
 546   Length = *Len;
 547   ZeroMem (TemStr, sizeof (TemStr));
 548   for (Index = 0; Index < Length; Index ++) {
 549     TemStr[0] = Str[Length - Index - 1];
 550     DigitUint8 = (UINT8) StrHexToUint64 (TemStr);
 551     if ((Index & 1) == 0) {
 552       Buf [Index/2] = DigitUint8;
 553     } else {
 554       Buf [Index/2] = (UINT8) ((DigitUint8 << 4) + Buf [Index/2]);
 555     }
 556   }
 557
 558   *Number = Buf;
 559   Status  = EFI_SUCCESS;
 560
 561 Exit:
 562   if (Str != NULL) {
 563     FreePool (Str);
 564   }
 565
 566   return Status;
 567 }
 568
 569 /**
 570   Create altcfg string.
 571
 572   @param  Result               The request result string.
 573   @param  ConfigHdr            The request head info. <ConfigHdr> format.
 574   @param  Offset               The offset of the parameter int he structure.
 575   @param  Width                The width of the parameter.
 576
 577
 578   @retval  The string with altcfg info append at the end.
 579 **/
 580 EFI_STRING
 581 CreateAltCfgString (
 582   IN     EFI_STRING     Result,
 583   IN     EFI_STRING     ConfigHdr,
 584   IN     UINTN          Offset,
 585   IN     UINTN          Width
 586   )
 587 {
 588   EFI_STRING StringPtr;
 589   EFI_STRING TmpStr;
 590   UINTN      NewLen;
 591
 592   NewLen = StrLen (Result);
 593   //
 594   // String Len = ConfigResp + AltConfig + AltConfig + 1("\0")
 595   //
 596   NewLen = (NewLen + ((1 + StrLen (ConfigHdr) + 8 + 4) + (8 + 4 + 7 + 4 + 7 + 4)) * 2 + 1) * sizeof (CHAR16);
 597   StringPtr = AllocateZeroPool (NewLen);
 598   if (StringPtr == NULL) {
 599     return NULL;
 600   }
 601
 602   TmpStr = StringPtr;
 603   if (Result != NULL) {
 604     StrCpyS (StringPtr, NewLen / sizeof (CHAR16), Result);
 605     StringPtr += StrLen (Result);
 606     FreePool (Result);
 607   }
 608
 609   UnicodeSPrint (
 610   StringPtr,
 611   (1 + StrLen (ConfigHdr) + 8 + 4 + 1) * sizeof (CHAR16),
 612   L"&%s&ALTCFG=%04x",
 613   ConfigHdr,
 614   EFI_HII_DEFAULT_CLASS_STANDARD
 615   );
 616   StringPtr += StrLen (StringPtr);
 617
 618   UnicodeSPrint (
 619     StringPtr,
 620     (8 + 4 + 7 + 4 + 7 + 4 + 1) * sizeof (CHAR16),
 621     L"&OFFSET=%04x&WIDTH=%04x&VALUE=%04x",
 622     Offset,
 623     Width,
 624     DEFAULT_CLASS_STANDARD_VALUE
 625     );
 626   StringPtr += StrLen (StringPtr);
 627
 628   UnicodeSPrint (
 629   StringPtr,
 630   (1 + StrLen (ConfigHdr) + 8 + 4 + 1) * sizeof (CHAR16),
 631   L"&%s&ALTCFG=%04x",
 632   ConfigHdr,
 633   EFI_HII_DEFAULT_CLASS_MANUFACTURING
 634   );
 635   StringPtr += StrLen (StringPtr);
 636
 637   UnicodeSPrint (
 638     StringPtr,
 639     (8 + 4 + 7 + 4 + 7 + 4 + 1) * sizeof (CHAR16),
 640     L"&OFFSET=%04x&WIDTH=%04x&VALUE=%04x",
 641     Offset,
 642     Width,
 643     DEFAULT_CLASS_MANUFACTURING_VALUE
 644     );
 645   StringPtr += StrLen (StringPtr);
 646
 647   return TmpStr;
 648 }
 649
 650 /**
 651   Check whether need to add the altcfg string. if need to add, add the altcfg
 652   string.
 653
 654   @param  RequestResult              The request result string.
 655   @param  ConfigRequestHdr           The request head info. <ConfigHdr> format.
 656
 657 **/
 658 VOID
 659 AppendAltCfgString (
 660   IN OUT EFI_STRING                       *RequestResult,
 661   IN     EFI_STRING                       ConfigRequestHdr
 662   )
 663 {
 664   EFI_STRING                          StringPtr;
 665   UINTN                               Length;
 666   UINT8                               *TmpBuffer;
 667   UINTN                               Offset;
 668   UINTN                               Width;
 669   UINTN                               BlockSize;
 670   UINTN                               ValueOffset;
 671   UINTN                               ValueWidth;
 672   EFI_STATUS                          Status;
 673
 674   TmpBuffer = NULL;
 675   StringPtr = *RequestResult;
 676   StringPtr = StrStr (StringPtr, L"OFFSET");
 677   BlockSize = sizeof (DRIVER_SAMPLE_CONFIGURATION);
 678   ValueOffset = OFFSET_OF (DRIVER_SAMPLE_CONFIGURATION, GetDefaultValueFromAccess);
 679   ValueWidth  = sizeof (((DRIVER_SAMPLE_CONFIGURATION *)0)->GetDefaultValueFromAccess);
 680
 681   if (StringPtr == NULL) {
 682     return;
 683   }
 684
 685   while (*StringPtr != 0 && StrnCmp (StringPtr, L"OFFSET=", StrLen (L"OFFSET=")) == 0) {
 686     StringPtr += StrLen (L"OFFSET=");
 687     //
 688     // Get Offset
 689     //
 690     Status = GetValueOfNumber (StringPtr, &TmpBuffer, &Length);
 691     if (EFI_ERROR (Status)) {
 692       return;
 693     }
 694     Offset = 0;
 695     CopyMem (
 696      &Offset,
 697      TmpBuffer,
 698      (((Length + 1) / 2) < sizeof (UINTN)) ? ((Length + 1) / 2) : sizeof (UINTN)
 699      );
 700     FreePool (TmpBuffer);
 701
 702     StringPtr += Length;
 703     if (StrnCmp (StringPtr, L"&WIDTH=", StrLen (L"&WIDTH=")) != 0) {
 704       return;
 705     }
 706     StringPtr += StrLen (L"&WIDTH=");
 707
 708     //
 709     // Get Width
 710     //
 711     Status = GetValueOfNumber (StringPtr, &TmpBuffer, &Length);
 712     if (EFI_ERROR (Status)) {
 713       return;
 714     }
 715     Width = 0;
 716     CopyMem (
 717      &Width,
 718      TmpBuffer,
 719      (((Length + 1) / 2) < sizeof (UINTN)) ? ((Length + 1) / 2) : sizeof (UINTN)
 720      );
 721     FreePool (TmpBuffer);
 722
 723     StringPtr += Length;
 724     if (StrnCmp (StringPtr, L"&VALUE=", StrLen (L"&VALUE=")) != 0) {
 725       return;
 726     }
 727     StringPtr += StrLen (L"&VALUE=");
 728
 729     //
 730     // Get Value
 731     //
 732     Status = GetValueOfNumber (StringPtr, &TmpBuffer, &Length);
 733     if (EFI_ERROR (Status)) {
 734       return;
 735     }
 736     StringPtr += Length;
 737
 738     //
 739     // Calculate Value and convert it to hex string.
 740     //
 741     if (Offset + Width > BlockSize) {
 742       return;
 743     }
 744
 745     if (Offset <= ValueOffset && Offset + Width >= ValueOffset + ValueWidth) {
 746       *RequestResult = CreateAltCfgString(*RequestResult, ConfigRequestHdr, ValueOffset, ValueWidth);
 747       return;
 748     }
 749   }
 750 }
 751
 752 /**
 753   This function allows a caller to extract the current configuration for one
 754   or more named elements from the target driver.
 755
 756   @param  This                   Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
 757   @param  Request                A null-terminated Unicode string in
 758                                  <ConfigRequest> format.
 759   @param  Progress               On return, points to a character in the Request
 760                                  string. Points to the string's null terminator if
 761                                  request was successful. Points to the most recent
 762                                  '&' before the first failing name/value pair (or
 763                                  the beginning of the string if the failure is in
 764                                  the first name/value pair) if the request was not
 765                                  successful.
 766   @param  Results                A null-terminated Unicode string in
 767                                  <ConfigAltResp> format which has all values filled
 768                                  in for the names in the Request string. String to
 769                                  be allocated by the called function.
 770
 771   @retval EFI_SUCCESS            The Results is filled with the requested values.
 772   @retval EFI_OUT_OF_RESOURCES   Not enough memory to store the results.
 773   @retval EFI_INVALID_PARAMETER  Request is illegal syntax, or unknown name.
 774   @retval EFI_NOT_FOUND          Routing data doesn't match any storage in this
 775                                  driver.
 776
 777 **/
 778 EFI_STATUS
 779 EFIAPI
 780 ExtractConfig (
 781   IN  CONST EFI_HII_CONFIG_ACCESS_PROTOCOL   *This,
 782   IN  CONST EFI_STRING                       Request,
 783   OUT EFI_STRING                             *Progress,
 784   OUT EFI_STRING                             *Results
 785   )
 786 {
 787   EFI_STATUS                       Status;
 788   UINTN                            BufferSize;
 789   DRIVER_SAMPLE_PRIVATE_DATA       *PrivateData;
 790   EFI_HII_CONFIG_ROUTING_PROTOCOL  *HiiConfigRouting;
 791   EFI_STRING                       ConfigRequest;
 792   EFI_STRING                       ConfigRequestHdr;
 793   UINTN                            Size;
 794   EFI_STRING                       Value;
 795   UINTN                            ValueStrLen;
 796   CHAR16                           BackupChar;
 797   CHAR16                           *StrPointer;
 798   BOOLEAN                          AllocatedRequest;
 799
 800   if (Progress == NULL || Results == NULL) {
 801     return EFI_INVALID_PARAMETER;
 802   }
 803   //
 804   // Initialize the local variables.
 805   //
 806   ConfigRequestHdr  = NULL;
 807   ConfigRequest     = NULL;
 808   Size              = 0;
 809   *Progress         = Request;
 810   AllocatedRequest  = FALSE;
 811
 812   PrivateData = DRIVER_SAMPLE_PRIVATE_FROM_THIS (This);
 813   HiiConfigRouting = PrivateData->HiiConfigRouting;
 814
 815   //
 816   // Get Buffer Storage data from EFI variable.
 817   // Try to get the current setting from variable.
 818   //
 819   BufferSize = sizeof (DRIVER_SAMPLE_CONFIGURATION);
 820   Status = gRT->GetVariable (
 821             VariableName,
 822             &gDriverSampleFormSetGuid,
 823             NULL,
 824             &BufferSize,
 825             &PrivateData->Configuration
 826             );
 827   if (EFI_ERROR (Status)) {
 828     return EFI_NOT_FOUND;
 829   }
 830
 831   if (Request == NULL) {
 832     //
 833     // Request is set to NULL, construct full request string.
 834     //
 835
 836     //
 837     // Allocate and fill a buffer large enough to hold the <ConfigHdr> template
 838     // followed by "&OFFSET=0&WIDTH=WWWWWWWWWWWWWWWW" followed by a Null-terminator
 839     //
 840     ConfigRequestHdr = HiiConstructConfigHdr (&gDriverSampleFormSetGuid, VariableName, PrivateData->DriverHandle[0]);
 841     Size = (StrLen (ConfigRequestHdr) + 32 + 1) * sizeof (CHAR16);
 842     ConfigRequest = AllocateZeroPool (Size);
 843     ASSERT (ConfigRequest != NULL);
 844     AllocatedRequest = TRUE;
 845     UnicodeSPrint (ConfigRequest, Size, L"%s&OFFSET=0&WIDTH=%016LX", ConfigRequestHdr, (UINT64)BufferSize);
 846     FreePool (ConfigRequestHdr);
 847     ConfigRequestHdr = NULL;
 848   } else {
 849     //
 850     // Check routing data in <ConfigHdr>.
 851     // Note: if only one Storage is used, then this checking could be skipped.
 852     //
 853     if (!HiiIsConfigHdrMatch (Request, &gDriverSampleFormSetGuid, NULL)) {
 854       return EFI_NOT_FOUND;
 855     }
 856     //
 857     // Check whether request for EFI Varstore. EFI varstore get data
 858     // through hii database, not support in this path.
 859     //
 860     if (HiiIsConfigHdrMatch(Request, &gDriverSampleFormSetGuid, MyEfiVar)) {
 861       return EFI_UNSUPPORTED;
 862     }
 863     //
 864     // Set Request to the unified request string.
 865     //
 866     ConfigRequest = Request;
 867     //
 868     // Check whether Request includes Request Element.
 869     //
 870     if (StrStr (Request, L"OFFSET") == NULL) {
 871       //
 872       // Check Request Element does exist in Reques String
 873       //
 874       StrPointer = StrStr (Request, L"PATH");
 875       if (StrPointer == NULL) {
 876         return EFI_INVALID_PARAMETER;
 877       }
 878       if (StrStr (StrPointer, L"&") == NULL) {
 879         Size = (StrLen (Request) + 32 + 1) * sizeof (CHAR16);
 880         ConfigRequest    = AllocateZeroPool (Size);
 881         ASSERT (ConfigRequest != NULL);
 882         AllocatedRequest = TRUE;
 883         UnicodeSPrint (ConfigRequest, Size, L"%s&OFFSET=0&WIDTH=%016LX", Request, (UINT64)BufferSize);
 884       }
 885     }
 886   }
 887
 888   //
 889   // Check if requesting Name/Value storage
 890   //
 891   if (StrStr (ConfigRequest, L"OFFSET") == NULL) {
 892     //
 893     // Update Name/Value storage Names
 894     //
 895     Status = LoadNameValueNames (PrivateData);
 896     if (EFI_ERROR (Status)) {
 897       return Status;
 898     }
 899
 900     //
 901     // Allocate memory for <ConfigResp>, e.g. Name0=0x11, Name1=0x1234, Name2="ABCD"
 902     // <Request>   ::=<ConfigHdr>&Name0&Name1&Name2
 903     // <ConfigResp>::=<ConfigHdr>&Name0=11&Name1=1234&Name2=0041004200430044
 904     //
 905     BufferSize = (StrLen (ConfigRequest) +
 906       1 + sizeof (PrivateData->Configuration.NameValueVar0) * 2 +
 907       1 + sizeof (PrivateData->Configuration.NameValueVar1) * 2 +
 908       1 + sizeof (PrivateData->Configuration.NameValueVar2) * 2 + 1) * sizeof (CHAR16);
 909     *Results = AllocateZeroPool (BufferSize);
 910     ASSERT (*Results != NULL);
 911     StrCpyS (*Results, BufferSize / sizeof (CHAR16), ConfigRequest);
 912     Value = *Results;
 913
 914     //
 915     // Append value of NameValueVar0, type is UINT8
 916     //
 917     if ((Value = StrStr (*Results, PrivateData->NameValueName[0])) != NULL) {
 918       Value += StrLen (PrivateData->NameValueName[0]);
 919       ValueStrLen = ((sizeof (PrivateData->Configuration.NameValueVar0) * 2) + 1);
 920       CopyMem (Value + ValueStrLen, Value, StrSize (Value));
 921
 922       BackupChar = Value[ValueStrLen];
 923       *Value++   = L'=';
 924       Value += UnicodeValueToString (
 925                  Value,
 926                  PREFIX_ZERO | RADIX_HEX,
 927                  PrivateData->Configuration.NameValueVar0,
 928                  sizeof (PrivateData->Configuration.NameValueVar0) * 2
 929                  );
 930       *Value = BackupChar;
 931     }
 932
 933     //
 934     // Append value of NameValueVar1, type is UINT16
 935     //
 936     if ((Value = StrStr (*Results, PrivateData->NameValueName[1])) != NULL) {
 937       Value += StrLen (PrivateData->NameValueName[1]);
 938       ValueStrLen = ((sizeof (PrivateData->Configuration.NameValueVar1) * 2) + 1);
 939       CopyMem (Value + ValueStrLen, Value, StrSize (Value));
 940
 941       BackupChar = Value[ValueStrLen];
 942       *Value++   = L'=';
 943       Value += UnicodeValueToString (
 944                 Value,
 945                 PREFIX_ZERO | RADIX_HEX,
 946                 PrivateData->Configuration.NameValueVar1,
 947                 sizeof (PrivateData->Configuration.NameValueVar1) * 2
 948                 );
 949       *Value = BackupChar;
 950     }
 951
 952     //
 953     // Append value of NameValueVar2, type is CHAR16 *
 954     //
 955     if ((Value = StrStr (*Results, PrivateData->NameValueName[2])) != NULL) {
 956       Value += StrLen (PrivateData->NameValueName[2]);
 957       ValueStrLen = StrLen (PrivateData->Configuration.NameValueVar2) * 4 + 1;
 958       CopyMem (Value + ValueStrLen, Value, StrSize (Value));
 959
 960       *Value++ = L'=';
 961       //
 962       // Convert Unicode String to Config String, e.g. "ABCD" => "0041004200430044"
 963       //
 964       StrPointer = (CHAR16 *) PrivateData->Configuration.NameValueVar2;
 965       for (; *StrPointer != L'\0'; StrPointer++) {
 966         Value += UnicodeValueToString (Value, PREFIX_ZERO | RADIX_HEX, *StrPointer, 4);
 967       }
 968     }
 969
 970     Status = EFI_SUCCESS;
 971   } else {
 972     //
 973     // Convert buffer data to <ConfigResp> by helper function BlockToConfig()
 974     //
 975     Status = HiiConfigRouting->BlockToConfig (
 976                                   HiiConfigRouting,
 977                                   ConfigRequest,
 978                                   (UINT8 *) &PrivateData->Configuration,
 979                                   BufferSize,
 980                                   Results,
 981                                   Progress
 982                                   );
 983     if (!EFI_ERROR (Status)) {
 984       ConfigRequestHdr = HiiConstructConfigHdr (&gDriverSampleFormSetGuid, VariableName, PrivateData->DriverHandle[0]);
 985       AppendAltCfgString(Results, ConfigRequestHdr);
 986     }
 987   }
 988
 989   //
 990   // Free the allocated config request string.
 991   //
 992   if (AllocatedRequest) {
 993     FreePool (ConfigRequest);
 994   }
 995
 996   if (ConfigRequestHdr != NULL) {
 997     FreePool (ConfigRequestHdr);
 998   }
 999   //
1000   // Set Progress string to the original request string.
1001   //
1002   if (Request == NULL) {
1003     *Progress = NULL;
1004   } else if (StrStr (Request, L"OFFSET") == NULL) {
1005     *Progress = Request + StrLen (Request);
1006   }
1007
1008   return Status;
1009 }
1010
1011
1012 /**
1013   This function processes the results of changes in configuration.
1014
1015   @param  This                   Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
1016   @param  Configuration          A null-terminated Unicode string in <ConfigResp>
1017                                  format.
1018   @param  Progress               A pointer to a string filled in with the offset of
1019                                  the most recent '&' before the first failing
1020                                  name/value pair (or the beginning of the string if
1021                                  the failure is in the first name/value pair) or
1022                                  the terminating NULL if all was successful.
1023
1024   @retval EFI_SUCCESS            The Results is processed successfully.
1025   @retval EFI_INVALID_PARAMETER  Configuration is NULL.
1026   @retval EFI_NOT_FOUND          Routing data doesn't match any storage in this
1027                                  driver.
1028
1029 **/
1030 EFI_STATUS
1031 EFIAPI
1032 RouteConfig (
1033   IN  CONST EFI_HII_CONFIG_ACCESS_PROTOCOL   *This,
1034   IN  CONST EFI_STRING                       Configuration,
1035   OUT EFI_STRING                             *Progress
1036   )
1037 {
1038   EFI_STATUS                       Status;
1039   UINTN                            BufferSize;
1040   DRIVER_SAMPLE_PRIVATE_DATA       *PrivateData;
1041   EFI_HII_CONFIG_ROUTING_PROTOCOL  *HiiConfigRouting;
1042   CHAR16                           *Value;
1043   CHAR16                           *StrPtr;
1044   CHAR16                           TemStr[5];
1045   UINT8                            *DataBuffer;
1046   UINT8                            DigitUint8;
1047   UINTN                            Index;
1048   CHAR16                           *StrBuffer;
1049
1050   if (Configuration == NULL || Progress == NULL) {
1051     return EFI_INVALID_PARAMETER;
1052   }
1053
1054   PrivateData = DRIVER_SAMPLE_PRIVATE_FROM_THIS (This);
1055   HiiConfigRouting = PrivateData->HiiConfigRouting;
1056   *Progress = Configuration;
1057
1058   //
1059   // Check routing data in <ConfigHdr>.
1060   // Note: if only one Storage is used, then this checking could be skipped.
1061   //
1062   if (!HiiIsConfigHdrMatch (Configuration, &gDriverSampleFormSetGuid, NULL)) {
1063     return EFI_NOT_FOUND;
1064   }
1065
1066   //
1067   // Check whether request for EFI Varstore. EFI varstore get data
1068   // through hii database, not support in this path.
1069   //
1070   if (HiiIsConfigHdrMatch(Configuration, &gDriverSampleFormSetGuid, MyEfiVar)) {
1071     return EFI_UNSUPPORTED;
1072   }
1073
1074   //
1075   // Get Buffer Storage data from EFI variable
1076   //
1077   BufferSize = sizeof (DRIVER_SAMPLE_CONFIGURATION);
1078   Status = gRT->GetVariable (
1079             VariableName,
1080             &gDriverSampleFormSetGuid,
1081             NULL,
1082             &BufferSize,
1083             &PrivateData->Configuration
1084             );
1085   if (EFI_ERROR (Status)) {
1086     return Status;
1087   }
1088
1089   //
1090   // Check if configuring Name/Value storage
1091   //
1092   if (StrStr (Configuration, L"OFFSET") == NULL) {
1093     //
1094     // Update Name/Value storage Names
1095     //
1096     Status = LoadNameValueNames (PrivateData);
1097     if (EFI_ERROR (Status)) {
1098       return Status;
1099     }
1100
1101     //
1102     // Convert value for NameValueVar0
1103     //
1104     if ((Value = StrStr (Configuration, PrivateData->NameValueName[0])) != NULL) {
1105       //
1106       // Skip "Name="
1107       //
1108       Value += StrLen (PrivateData->NameValueName[0]);
1109       Value++;
1110       //
1111       // Get Value String
1112       //
1113       StrPtr = StrStr (Value, L"&");
1114       if (StrPtr == NULL) {
1115         StrPtr = Value + StrLen (Value);
1116       }
1117       //
1118       // Convert Value to Buffer data
1119       //
1120       DataBuffer = (UINT8 *) &PrivateData->Configuration.NameValueVar0;
1121       ZeroMem (TemStr, sizeof (TemStr));
1122       for (Index = 0, StrPtr --; StrPtr >= Value; StrPtr --, Index ++) {
1123         TemStr[0] = *StrPtr;
1124         DigitUint8 = (UINT8) StrHexToUint64 (TemStr);
1125         if ((Index & 1) == 0) {
1126           DataBuffer [Index/2] = DigitUint8;
1127         } else {
1128           DataBuffer [Index/2] = (UINT8) ((UINT8) (DigitUint8 << 4) + DataBuffer [Index/2]);
1129         }
1130       }
1131     }
1132
1133     //
1134     // Convert value for NameValueVar1
1135     //
1136     if ((Value = StrStr (Configuration, PrivateData->NameValueName[1])) != NULL) {
1137       //
1138       // Skip "Name="
1139       //
1140       Value += StrLen (PrivateData->NameValueName[1]);
1141       Value++;
1142       //
1143       // Get Value String
1144       //
1145       StrPtr = StrStr (Value, L"&");
1146       if (StrPtr == NULL) {
1147         StrPtr = Value + StrLen (Value);
1148       }
1149       //
1150       // Convert Value to Buffer data
1151       //
1152       DataBuffer = (UINT8 *) &PrivateData->Configuration.NameValueVar1;
1153       ZeroMem (TemStr, sizeof (TemStr));
1154       for (Index = 0, StrPtr --; StrPtr >= Value; StrPtr --, Index ++) {
1155         TemStr[0] = *StrPtr;
1156         DigitUint8 = (UINT8) StrHexToUint64 (TemStr);
1157         if ((Index & 1) == 0) {
1158           DataBuffer [Index/2] = DigitUint8;
1159         } else {
1160           DataBuffer [Index/2] = (UINT8) ((UINT8) (DigitUint8 << 4) + DataBuffer [Index/2]);
1161         }
1162       }
1163     }
1164
1165     //
1166     // Convert value for NameValueVar2
1167     //
1168     if ((Value = StrStr (Configuration, PrivateData->NameValueName[2])) != NULL) {
1169       //
1170       // Skip "Name="
1171       //
1172       Value += StrLen (PrivateData->NameValueName[2]);
1173       Value++;
1174       //
1175       // Get Value String
1176       //
1177       StrPtr = StrStr (Value, L"&");
1178       if (StrPtr == NULL) {
1179         StrPtr = Value + StrLen (Value);
1180       }
1181       //
1182       // Convert Config String to Unicode String, e.g "0041004200430044" => "ABCD"
1183       //
1184       StrBuffer = (CHAR16 *) PrivateData->Configuration.NameValueVar2;
1185       ZeroMem (TemStr, sizeof (TemStr));
1186       while (Value < StrPtr) {
1187         StrnCpyS (TemStr, sizeof (TemStr) / sizeof (CHAR16), Value, 4);
1188         *(StrBuffer++) = (CHAR16) StrHexToUint64 (TemStr);
1189         Value += 4;
1190       }
1191       *StrBuffer = L'\0';
1192     }
1193
1194     //
1195     // Store Buffer Storage back to EFI variable
1196     //
1197     Status = gRT->SetVariable(
1198       VariableName,
1199       &gDriverSampleFormSetGuid,
1200       EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
1201       sizeof (DRIVER_SAMPLE_CONFIGURATION),
1202       &PrivateData->Configuration
1203       );
1204
1205     return Status;
1206   }
1207
1208   //
1209   // Convert <ConfigResp> to buffer data by helper function ConfigToBlock()
1210   //
1211   BufferSize = sizeof (DRIVER_SAMPLE_CONFIGURATION);
1212   Status = HiiConfigRouting->ConfigToBlock (
1213                                HiiConfigRouting,
1214                                Configuration,
1215                                (UINT8 *) &PrivateData->Configuration,
1216                                &BufferSize,
1217                                Progress
1218                                );
1219   if (EFI_ERROR (Status)) {
1220     return Status;
1221   }
1222
1223   //
1224   // Store Buffer Storage back to EFI variable
1225   //
1226   Status = gRT->SetVariable(
1227                   VariableName,
1228                   &gDriverSampleFormSetGuid,
1229                   EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
1230                   sizeof (DRIVER_SAMPLE_CONFIGURATION),
1231                   &PrivateData->Configuration
1232                   );
1233
1234   return Status;
1235 }
1236
1237
1238 /**
1239   This function processes the results of changes in configuration.
1240
1241   @param  This                   Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
1242   @param  Action                 Specifies the type of action taken by the browser.
1243   @param  QuestionId             A unique value which is sent to the original
1244                                  exporting driver so that it can identify the type
1245                                  of data to expect.
1246   @param  Type                   The type of value for the question.
1247   @param  Value                  A pointer to the data being sent to the original
1248                                  exporting driver.
1249   @param  ActionRequest          On return, points to the action requested by the
1250                                  callback function.
1251
1252   @retval EFI_SUCCESS            The callback successfully handled the action.
1253   @retval EFI_OUT_OF_RESOURCES   Not enough storage is available to hold the
1254                                  variable and its data.
1255   @retval EFI_DEVICE_ERROR       The variable could not be saved.
1256   @retval EFI_UNSUPPORTED        The specified Action is not supported by the
1257                                  callback.
1258
1259 **/
1260 EFI_STATUS
1261 EFIAPI
1262 DriverCallback (
1263   IN  CONST EFI_HII_CONFIG_ACCESS_PROTOCOL   *This,
1264   IN  EFI_BROWSER_ACTION                     Action,
1265   IN  EFI_QUESTION_ID                        QuestionId,
1266   IN  UINT8                                  Type,
1267   IN  EFI_IFR_TYPE_VALUE                     *Value,
1268   OUT EFI_BROWSER_ACTION_REQUEST             *ActionRequest
1269   )
1270 {
1271   DRIVER_SAMPLE_PRIVATE_DATA      *PrivateData;
1272   EFI_STATUS                      Status;
1273   VOID                            *StartOpCodeHandle;
1274   VOID                            *OptionsOpCodeHandle;
1275   EFI_IFR_GUID_LABEL              *StartLabel;
1276   VOID                            *EndOpCodeHandle;
1277   EFI_IFR_GUID_LABEL              *EndLabel;
1278   EFI_INPUT_KEY                   Key;
1279   DRIVER_SAMPLE_CONFIGURATION     *Configuration;
1280   MY_EFI_VARSTORE_DATA            *EfiData;
1281   EFI_FORM_ID                     FormId;
1282   EFI_STRING                      Progress;
1283   EFI_STRING                      Results;
1284   UINT32                          ProgressErr;
1285   CHAR16                          *TmpStr;
1286
1287   if (((Value == NULL) && (Action != EFI_BROWSER_ACTION_FORM_OPEN) && (Action != EFI_BROWSER_ACTION_FORM_CLOSE))||
1288     (ActionRequest == NULL)) {
1289     return EFI_INVALID_PARAMETER;
1290   }
1291
1292
1293   FormId = 0;
1294   ProgressErr = 0;
1295   Status = EFI_SUCCESS;
1296   PrivateData = DRIVER_SAMPLE_PRIVATE_FROM_THIS (This);
1297
1298   switch (Action) {
1299   case EFI_BROWSER_ACTION_FORM_OPEN:
1300     {
1301       if (QuestionId == 0x1234) {
1302         //
1303         // Sample CallBack for UEFI FORM_OPEN action:
1304         //   Add Save action into Form 3 when Form 1 is opened.
1305         //   This will be done only in FORM_OPEN CallBack of question with ID 0x1234 from Form 1.
1306         //
1307         PrivateData = DRIVER_SAMPLE_PRIVATE_FROM_THIS (This);
1308
1309         //
1310         // Initialize the container for dynamic opcodes
1311         //
1312         StartOpCodeHandle = HiiAllocateOpCodeHandle ();
1313         ASSERT (StartOpCodeHandle != NULL);
1314
1315         //
1316         // Create Hii Extend Label OpCode as the start opcode
1317         //
1318         StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (StartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
1319         StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
1320         StartLabel->Number       = LABEL_UPDATE2;
1321
1322         HiiCreateActionOpCode (
1323           StartOpCodeHandle,                // Container for dynamic created opcodes
1324           0x1238,                           // Question ID
1325           STRING_TOKEN(STR_SAVE_TEXT),      // Prompt text
1326           STRING_TOKEN(STR_SAVE_TEXT),      // Help text
1327           EFI_IFR_FLAG_CALLBACK,            // Question flag
1328           0                                 // Action String ID
1329         );
1330
1331         HiiUpdateForm (
1332           PrivateData->HiiHandle[0],  // HII handle
1333           &gDriverSampleFormSetGuid,  // Formset GUID
1334           0x3,                        // Form ID
1335           StartOpCodeHandle,          // Label for where to insert opcodes
1336           NULL                        // Insert data
1337           );
1338
1339         HiiFreeOpCodeHandle (StartOpCodeHandle);
1340       }
1341
1342       if (QuestionId == 0x1247) {
1343         Status = InternalStartMonitor ();
1344         ASSERT_EFI_ERROR (Status);
1345       }
1346     }
1347     break;
1348
1349   case EFI_BROWSER_ACTION_FORM_CLOSE:
1350     {
1351       if (QuestionId == 0x5678) {
1352         //
1353         // Sample CallBack for UEFI FORM_CLOSE action:
1354         //   Show up a pop-up to specify Form 3 will be closed when exit Form 3.
1355         //
1356         do {
1357           CreatePopUp (
1358             EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
1359             &Key,
1360             L"",
1361             L"You are going to leave third Form!",
1362             L"Press ESC or ENTER to continue ...",
1363             L"",
1364             NULL
1365             );
1366         } while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));
1367       }
1368
1369       if (QuestionId == 0x1247) {
1370         Status = InternalStopMonitor ();
1371         ASSERT_EFI_ERROR (Status);
1372       }
1373     }
1374     break;
1375
1376   case EFI_BROWSER_ACTION_RETRIEVE:
1377     {
1378       if (QuestionId == 0x1248) {
1379         {
1380           if (Type != EFI_IFR_TYPE_REF) {
1381             return EFI_INVALID_PARAMETER;
1382           }
1383
1384           Value->ref.FormId = 0x3;
1385         }
1386       }
1387     }
1388     break;
1389
1390   case EFI_BROWSER_ACTION_DEFAULT_STANDARD:
1391     {
1392       switch (QuestionId) {
1393       case 0x1240:
1394         Value->u8 = DEFAULT_CLASS_STANDARD_VALUE;
1395       break;
1396
1397       default:
1398         Status = EFI_UNSUPPORTED;
1399       break;
1400       }
1401     }
1402     break;
1403
1404   case EFI_BROWSER_ACTION_DEFAULT_MANUFACTURING:
1405     {
1406       switch (QuestionId) {
1407       case 0x1240:
1408         Value->u8 = DEFAULT_CLASS_MANUFACTURING_VALUE;
1409       break;
1410
1411       default:
1412         Status = EFI_UNSUPPORTED;
1413       break;
1414       }
1415     }
1416     break;
1417
1418   case EFI_BROWSER_ACTION_CHANGING:
1419   {
1420     switch (QuestionId) {
1421     case 0x1249:
1422       {
1423         if (Type != EFI_IFR_TYPE_REF) {
1424           return EFI_INVALID_PARAMETER;
1425         }
1426
1427         Value->ref.FormId = 0x1234;
1428       }
1429     break;
1430     case 0x1234:
1431       //
1432       // Initialize the container for dynamic opcodes
1433       //
1434       StartOpCodeHandle = HiiAllocateOpCodeHandle ();
1435       ASSERT (StartOpCodeHandle != NULL);
1436
1437       EndOpCodeHandle = HiiAllocateOpCodeHandle ();
1438       ASSERT (EndOpCodeHandle != NULL);
1439
1440       //
1441       // Create Hii Extend Label OpCode as the start opcode
1442       //
1443       StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (StartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
1444       StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
1445       StartLabel->Number       = LABEL_UPDATE1;
1446
1447       //
1448       // Create Hii Extend Label OpCode as the end opcode
1449       //
1450       EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (EndOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
1451       EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
1452       EndLabel->Number       = LABEL_END;
1453
1454       HiiCreateActionOpCode (
1455         StartOpCodeHandle,                // Container for dynamic created opcodes
1456         0x1237,                           // Question ID
1457         STRING_TOKEN(STR_EXIT_TEXT),      // Prompt text
1458         STRING_TOKEN(STR_EXIT_TEXT),      // Help text
1459         EFI_IFR_FLAG_CALLBACK,            // Question flag
1460         0                                 // Action String ID
1461       );
1462
1463       //
1464       // Create Option OpCode
1465       //
1466       OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
1467       ASSERT (OptionsOpCodeHandle != NULL);
1468
1469       HiiCreateOneOfOptionOpCode (
1470         OptionsOpCodeHandle,
1471         STRING_TOKEN (STR_BOOT_OPTION1),
1472         0,
1473         EFI_IFR_NUMERIC_SIZE_1,
1474         1
1475         );
1476
1477       HiiCreateOneOfOptionOpCode (
1478         OptionsOpCodeHandle,
1479         STRING_TOKEN (STR_BOOT_OPTION2),
1480         0,
1481         EFI_IFR_NUMERIC_SIZE_1,
1482         2
1483         );
1484
1485       //
1486       // Prepare initial value for the dynamic created oneof Question
1487       //
1488       PrivateData->Configuration.DynamicOneof = 2;
1489       Status = gRT->SetVariable(
1490                       VariableName,
1491                       &gDriverSampleFormSetGuid,
1492                       EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
1493                       sizeof (DRIVER_SAMPLE_CONFIGURATION),
1494                       &PrivateData->Configuration
1495                       );
1496
1497       //
1498       // Set initial vlaue of dynamic created oneof Question in Form Browser
1499       //
1500       Configuration = AllocateZeroPool (sizeof (DRIVER_SAMPLE_CONFIGURATION));
1501       ASSERT (Configuration != NULL);
1502       if (HiiGetBrowserData (&gDriverSampleFormSetGuid, VariableName, sizeof (DRIVER_SAMPLE_CONFIGURATION), (UINT8 *) Configuration)) {
1503         Configuration->DynamicOneof = 2;
1504
1505         //
1506         // Update uncommitted data of Browser
1507         //
1508         HiiSetBrowserData (
1509           &gDriverSampleFormSetGuid,
1510           VariableName,
1511           sizeof (DRIVER_SAMPLE_CONFIGURATION),
1512           (UINT8 *) Configuration,
1513           NULL
1514           );
1515       }
1516       FreePool (Configuration);
1517
1518       HiiCreateOneOfOpCode (
1519         StartOpCodeHandle,                         // Container for dynamic created opcodes
1520         0x8001,                                    // Question ID (or call it "key")
1521         CONFIGURATION_VARSTORE_ID,                 // VarStore ID
1522         (UINT16) DYNAMIC_ONE_OF_VAR_OFFSET,        // Offset in Buffer Storage
1523         STRING_TOKEN (STR_ONE_OF_PROMPT),          // Question prompt text
1524         STRING_TOKEN (STR_ONE_OF_HELP),            // Question help text
1525         EFI_IFR_FLAG_CALLBACK,                     // Question flag
1526         EFI_IFR_NUMERIC_SIZE_1,                    // Data type of Question Value
1527         OptionsOpCodeHandle,                       // Option Opcode list
1528         NULL                                       // Default Opcode is NULl
1529         );
1530
1531       HiiCreateOrderedListOpCode (
1532         StartOpCodeHandle,                         // Container for dynamic created opcodes
1533         0x8002,                                    // Question ID
1534         CONFIGURATION_VARSTORE_ID,                 // VarStore ID
1535         (UINT16) DYNAMIC_ORDERED_LIST_VAR_OFFSET,  // Offset in Buffer Storage
1536         STRING_TOKEN (STR_BOOT_OPTIONS),           // Question prompt text
1537         STRING_TOKEN (STR_BOOT_OPTIONS),           // Question help text
1538         EFI_IFR_FLAG_RESET_REQUIRED,               // Question flag
1539         0,                                         // Ordered list flag, e.g. EFI_IFR_UNIQUE_SET
1540         EFI_IFR_NUMERIC_SIZE_1,                    // Data type of Question value
1541         5,                                         // Maximum container
1542         OptionsOpCodeHandle,                       // Option Opcode list
1543         NULL                                       // Default Opcode is NULl
1544         );
1545
1546       HiiCreateTextOpCode (
1547         StartOpCodeHandle,
1548         STRING_TOKEN(STR_TEXT_SAMPLE_HELP),
1549         STRING_TOKEN(STR_TEXT_SAMPLE_HELP),
1550         STRING_TOKEN(STR_TEXT_SAMPLE_STRING)
1551       );
1552
1553       HiiCreateDateOpCode (
1554         StartOpCodeHandle,
1555         0x8004,
1556         0x0,
1557         0x0,
1558         STRING_TOKEN(STR_DATE_SAMPLE_HELP),
1559         STRING_TOKEN(STR_DATE_SAMPLE_HELP),
1560         0,
1561         QF_DATE_STORAGE_TIME,
1562         NULL
1563         );
1564
1565       HiiCreateTimeOpCode (
1566         StartOpCodeHandle,
1567         0x8005,
1568         0x0,
1569         0x0,
1570         STRING_TOKEN(STR_TIME_SAMPLE_HELP),
1571         STRING_TOKEN(STR_TIME_SAMPLE_HELP),
1572         0,
1573         QF_TIME_STORAGE_TIME,
1574         NULL
1575         );
1576
1577       HiiCreateGotoOpCode (
1578         StartOpCodeHandle,                // Container for dynamic created opcodes
1579         1,                                // Target Form ID
1580         STRING_TOKEN (STR_GOTO_FORM1),    // Prompt text
1581         STRING_TOKEN (STR_GOTO_HELP),     // Help text
1582         0,                                // Question flag
1583         0x8003                            // Question ID
1584         );
1585
1586       HiiUpdateForm (
1587         PrivateData->HiiHandle[0],  // HII handle
1588         &gDriverSampleFormSetGuid,  // Formset GUID
1589         0x1234,                     // Form ID
1590         StartOpCodeHandle,          // Label for where to insert opcodes
1591         EndOpCodeHandle             // Replace data
1592         );
1593
1594       HiiFreeOpCodeHandle (StartOpCodeHandle);
1595       HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1596       HiiFreeOpCodeHandle (EndOpCodeHandle);
1597       break;
1598
1599     case 0x5678:
1600     case 0x1247:
1601       //
1602       // We will reach here once the Question is refreshed
1603       //
1604
1605       //
1606       // Initialize the container for dynamic opcodes
1607       //
1608       StartOpCodeHandle = HiiAllocateOpCodeHandle ();
1609       ASSERT (StartOpCodeHandle != NULL);
1610
1611       //
1612       // Create Hii Extend Label OpCode as the start opcode
1613       //
1614       StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (StartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
1615       StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
1616       if (QuestionId == 0x5678) {
1617         StartLabel->Number       = LABEL_UPDATE2;
1618         FormId                   = 0x03;
1619         PrivateData->Configuration.DynamicRefresh++;
1620       } else if (QuestionId == 0x1247 ) {
1621         StartLabel->Number       = LABEL_UPDATE3;
1622         FormId                   = 0x06;
1623         PrivateData->Configuration.RefreshGuidCount++;
1624       }
1625
1626       HiiCreateActionOpCode (
1627         StartOpCodeHandle,                // Container for dynamic created opcodes
1628         0x1237,                           // Question ID
1629         STRING_TOKEN(STR_EXIT_TEXT),      // Prompt text
1630         STRING_TOKEN(STR_EXIT_TEXT),      // Help text
1631         EFI_IFR_FLAG_CALLBACK,            // Question flag
1632         0                                 // Action String ID
1633       );
1634
1635       HiiUpdateForm (
1636         PrivateData->HiiHandle[0],  // HII handle
1637         &gDriverSampleFormSetGuid,              // Formset GUID
1638         FormId,                        // Form ID
1639         StartOpCodeHandle,          // Label for where to insert opcodes
1640         NULL                        // Insert data
1641         );
1642
1643       HiiFreeOpCodeHandle (StartOpCodeHandle);
1644
1645       //
1646       // Refresh the Question value
1647       //
1648       Status = gRT->SetVariable(
1649                       VariableName,
1650                       &gDriverSampleFormSetGuid,
1651                       EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
1652                       sizeof (DRIVER_SAMPLE_CONFIGURATION),
1653                       &PrivateData->Configuration
1654                       );
1655
1656       if (QuestionId == 0x5678) {
1657         //
1658         // Update uncommitted data of Browser
1659         //
1660         EfiData = AllocateZeroPool (sizeof (MY_EFI_VARSTORE_DATA));
1661         ASSERT (EfiData != NULL);
1662         if (HiiGetBrowserData (&gDriverSampleFormSetGuid, MyEfiVar, sizeof (MY_EFI_VARSTORE_DATA), (UINT8 *) EfiData)) {
1663           EfiData->Field8 = 111;
1664           HiiSetBrowserData (
1665             &gDriverSampleFormSetGuid,
1666             MyEfiVar,
1667             sizeof (MY_EFI_VARSTORE_DATA),
1668             (UINT8 *) EfiData,
1669             NULL
1670             );
1671         }
1672         FreePool (EfiData);
1673       }
1674       break;
1675
1676     case 0x2000:
1677       //
1678       // Only used to update the state.
1679       //
1680       if ((Type == EFI_IFR_TYPE_STRING) && (Value->string == 0) &&
1681         (PrivateData->PasswordState == BROWSER_STATE_SET_PASSWORD)) {
1682         PrivateData->PasswordState = BROWSER_STATE_VALIDATE_PASSWORD;
1683         return EFI_INVALID_PARAMETER;
1684       }
1685
1686       //
1687       // When try to set a new password, user will be chanlleged with old password.
1688       // The Callback is responsible for validating old password input by user,
1689       // If Callback return EFI_SUCCESS, it indicates validation pass.
1690       //
1691       switch (PrivateData->PasswordState) {
1692       case BROWSER_STATE_VALIDATE_PASSWORD:
1693         Status = ValidatePassword (PrivateData, Value->string);
1694         if (Status == EFI_SUCCESS) {
1695           PrivateData->PasswordState = BROWSER_STATE_SET_PASSWORD;
1696         }
1697         break;
1698
1699       case BROWSER_STATE_SET_PASSWORD:
1700         Status = SetPassword (PrivateData, Value->string);
1701         PrivateData->PasswordState = BROWSER_STATE_VALIDATE_PASSWORD;
1702         break;
1703
1704       default:
1705         break;
1706       }
1707
1708       break;
1709
1710     default:
1711       break;
1712     }
1713   }
1714   break;
1715
1716   case EFI_BROWSER_ACTION_CHANGED:
1717     switch (QuestionId) {
1718       case 0x1237:
1719         //
1720         // User press "Exit now", request Browser to exit
1721         //
1722         *ActionRequest = EFI_BROWSER_ACTION_REQUEST_EXIT;
1723         break;
1724
1725       case 0x1238:
1726         //
1727         // User press "Save now", request Browser to save the uncommitted data.
1728         //
1729         *ActionRequest = EFI_BROWSER_ACTION_REQUEST_SUBMIT;
1730         break;
1731
1732       case 0x1241:
1733       case 0x1246:
1734         //
1735         // User press "Submit current form and Exit now", request Browser to submit current form and exit
1736         //
1737         *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_SUBMIT_EXIT;
1738         break;
1739
1740       case 0x1242:
1741         //
1742         // User press "Discard current form now", request Browser to discard the uncommitted data.
1743         //
1744         *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_DISCARD;
1745         break;
1746
1747       case 0x1243:
1748         //
1749         // User press "Submit current form now", request Browser to save the uncommitted data.
1750         //
1751         *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_APPLY;
1752         break;
1753
1754       case 0x1244:
1755       case 0x1245:
1756         //
1757         // User press "Discard current form and Exit now", request Browser to discard the uncommitted data and exit.
1758         //
1759         *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_DISCARD_EXIT;
1760         break;
1761
1762       case 0x1231:
1763         //
1764         // 1. Check to see whether system support keyword.
1765         //
1766         Status = PrivateData->HiiKeywordHandler->GetData (PrivateData->HiiKeywordHandler,
1767                                                           L"NAMESPACE=x-UEFI-ns",
1768                                                           L"KEYWORD=iSCSIBootEnable",
1769                                                           &Progress,
1770                                                           &ProgressErr,
1771                                                           &Results
1772                                                          );
1773         if (EFI_ERROR (Status)) {
1774           do {
1775             CreatePopUp (
1776               EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
1777               &Key,
1778               L"",
1779               L"This system not support this keyword!",
1780               L"Press ENTER to continue ...",
1781               L"",
1782               NULL
1783               );
1784           } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);
1785
1786           Status = EFI_SUCCESS;
1787           break;
1788         }
1789
1790         //
1791         // 2. If system support this keyword, just try to change value.
1792         //
1793
1794         //
1795         // Change value from '0' to '1' or from '1' to '0'
1796         //
1797         TmpStr = StrStr (Results, L"&VALUE=");
1798         ASSERT (TmpStr != NULL);
1799         TmpStr += StrLen (L"&VALUE=");
1800         TmpStr++;
1801         if (*TmpStr == L'0') {
1802           *TmpStr = L'1';
1803         } else {
1804           *TmpStr = L'0';
1805         }
1806
1807         //
1808         // 3. Call the keyword handler protocol to change the value.
1809         //
1810         Status = PrivateData->HiiKeywordHandler->SetData (PrivateData->HiiKeywordHandler,
1811                                                           Results,
1812                                                           &Progress,
1813                                                           &ProgressErr
1814                                                          );
1815         if (EFI_ERROR (Status)) {
1816           do {
1817             CreatePopUp (
1818               EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
1819               &Key,
1820               L"",
1821               L"Set keyword to the system failed!",
1822               L"Press ENTER to continue ...",
1823               L"",
1824               NULL
1825               );
1826           } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);
1827
1828           Status = EFI_SUCCESS;
1829           break;
1830         }
1831         break;
1832
1833       default:
1834       break;
1835     }
1836   break;
1837
1838   default:
1839     Status = EFI_UNSUPPORTED;
1840     break;
1841   }
1842
1843   return Status;
1844 }
1845
1846 /**
1847   Main entry for this driver.
1848
1849   @param ImageHandle     Image handle this driver.
1850   @param SystemTable     Pointer to SystemTable.
1851
1852   @retval EFI_SUCESS     This function always complete successfully.
1853
1854 **/
1855 EFI_STATUS
1856 EFIAPI
1857 DriverSampleInit (
1858   IN EFI_HANDLE                   ImageHandle,
1859   IN EFI_SYSTEM_TABLE             *SystemTable
1860   )
1861 {
1862   EFI_STATUS                      Status;
1863   EFI_HII_HANDLE                  HiiHandle[2];
1864   EFI_SCREEN_DESCRIPTOR           Screen;
1865   EFI_HII_DATABASE_PROTOCOL       *HiiDatabase;
1866   EFI_HII_STRING_PROTOCOL         *HiiString;
1867   EFI_FORM_BROWSER2_PROTOCOL      *FormBrowser2;
1868   EFI_HII_CONFIG_ROUTING_PROTOCOL *HiiConfigRouting;
1869   EFI_CONFIG_KEYWORD_HANDLER_PROTOCOL *HiiKeywordHandler;
1870   CHAR16                          *NewString;
1871   UINTN                           BufferSize;
1872   DRIVER_SAMPLE_CONFIGURATION     *Configuration;
1873   BOOLEAN                         ActionFlag;
1874   EFI_STRING                      ConfigRequestHdr;
1875   EFI_STRING                      NameRequestHdr;
1876   MY_EFI_VARSTORE_DATA            *VarStoreConfig;
1877   EFI_INPUT_KEY                   HotKey;
1878   EFI_FORM_BROWSER_EXTENSION_PROTOCOL *FormBrowserEx;
1879
1880   //
1881   // Initialize the local variables.
1882   //
1883   ConfigRequestHdr = NULL;
1884   NewString        = NULL;
1885
1886   //
1887   // Initialize screen dimensions for SendForm().
1888   // Remove 3 characters from top and bottom
1889   //
1890   ZeroMem (&Screen, sizeof (EFI_SCREEN_DESCRIPTOR));
1891   gST->ConOut->QueryMode (gST->ConOut, gST->ConOut->Mode->Mode, &Screen.RightColumn, &Screen.BottomRow);
1892
1893   Screen.TopRow     = 3;
1894   Screen.BottomRow  = Screen.BottomRow - 3;
1895
1896   //
1897   // Initialize driver private data
1898   //
1899   PrivateData = AllocateZeroPool (sizeof (DRIVER_SAMPLE_PRIVATE_DATA));
1900   if (PrivateData == NULL) {
1901     return EFI_OUT_OF_RESOURCES;
1902   }
1903
1904   PrivateData->Signature = DRIVER_SAMPLE_PRIVATE_SIGNATURE;
1905
1906   PrivateData->ConfigAccess.ExtractConfig = ExtractConfig;
1907   PrivateData->ConfigAccess.RouteConfig = RouteConfig;
1908   PrivateData->ConfigAccess.Callback = DriverCallback;
1909   PrivateData->PasswordState = BROWSER_STATE_VALIDATE_PASSWORD;
1910
1911   //
1912   // Locate Hii Database protocol
1913   //
1914   Status = gBS->LocateProtocol (&gEfiHiiDatabaseProtocolGuid, NULL, (VOID **) &HiiDatabase);
1915   if (EFI_ERROR (Status)) {
1916     return Status;
1917   }
1918   PrivateData->HiiDatabase = HiiDatabase;
1919
1920   //
1921   // Locate HiiString protocol
1922   //
1923   Status = gBS->LocateProtocol (&gEfiHiiStringProtocolGuid, NULL, (VOID **) &HiiString);
1924   if (EFI_ERROR (Status)) {
1925     return Status;
1926   }
1927   PrivateData->HiiString = HiiString;
1928
1929   //
1930   // Locate Formbrowser2 protocol
1931   //
1932   Status = gBS->LocateProtocol (&gEfiFormBrowser2ProtocolGuid, NULL, (VOID **) &FormBrowser2);
1933   if (EFI_ERROR (Status)) {
1934     return Status;
1935   }
1936   PrivateData->FormBrowser2 = FormBrowser2;
1937
1938   //
1939   // Locate ConfigRouting protocol
1940   //
1941   Status = gBS->LocateProtocol (&gEfiHiiConfigRoutingProtocolGuid, NULL, (VOID **) &HiiConfigRouting);
1942   if (EFI_ERROR (Status)) {
1943     return Status;
1944   }
1945   PrivateData->HiiConfigRouting = HiiConfigRouting;
1946
1947   //
1948   // Locate keyword handler protocol
1949   //
1950   Status = gBS->LocateProtocol (&gEfiConfigKeywordHandlerProtocolGuid, NULL, (VOID **) &HiiKeywordHandler);
1951   if (EFI_ERROR (Status)) {
1952     return Status;
1953   }
1954   PrivateData->HiiKeywordHandler = HiiKeywordHandler;
1955
1956   Status = gBS->InstallMultipleProtocolInterfaces (
1957                   &DriverHandle[0],
1958                   &gEfiDevicePathProtocolGuid,
1959                   &mHiiVendorDevicePath0,
1960                   &gEfiHiiConfigAccessProtocolGuid,
1961                   &PrivateData->ConfigAccess,
1962                   NULL
1963                   );
1964   ASSERT_EFI_ERROR (Status);
1965
1966   PrivateData->DriverHandle[0] = DriverHandle[0];
1967
1968   //
1969   // Publish our HII data
1970   //
1971   HiiHandle[0] = HiiAddPackages (
1972                    &gDriverSampleFormSetGuid,
1973                    DriverHandle[0],
1974                    DriverSampleStrings,
1975                    VfrBin,
1976                    NULL
1977                    );
1978   if (HiiHandle[0] == NULL) {
1979     return EFI_OUT_OF_RESOURCES;
1980   }
1981
1982   PrivateData->HiiHandle[0] = HiiHandle[0];
1983
1984   //
1985   // Publish another Fromset
1986   //
1987   Status = gBS->InstallMultipleProtocolInterfaces (
1988                   &DriverHandle[1],
1989                   &gEfiDevicePathProtocolGuid,
1990                   &mHiiVendorDevicePath1,
1991                   &gEfiHiiConfigAccessProtocolGuid,
1992                   &PrivateData->ConfigAccess,
1993                   NULL
1994                   );
1995   ASSERT_EFI_ERROR (Status);
1996
1997   PrivateData->DriverHandle[1] = DriverHandle[1];
1998
1999   HiiHandle[1] = HiiAddPackages (
2000                    &gDriverSampleInventoryGuid,
2001                    DriverHandle[1],
2002                    DriverSampleStrings,
2003                    InventoryBin,
2004                    NULL
2005                    );
2006   if (HiiHandle[1] == NULL) {
2007     DriverSampleUnload (ImageHandle);
2008     return EFI_OUT_OF_RESOURCES;
2009   }
2010
2011   PrivateData->HiiHandle[1] = HiiHandle[1];
2012
2013   //
2014   // Update the device path string.
2015   //
2016   NewString = ConvertDevicePathToText((EFI_DEVICE_PATH_PROTOCOL*)&mHiiVendorDevicePath0, FALSE, FALSE);
2017   if (HiiSetString (HiiHandle[0], STRING_TOKEN (STR_DEVICE_PATH), NewString, NULL) == 0) {
2018     DriverSampleUnload (ImageHandle);
2019     return EFI_OUT_OF_RESOURCES;
2020   }
2021   if (NewString != NULL) {
2022     FreePool (NewString);
2023   }
2024
2025   //
2026   // Very simple example of how one would update a string that is already
2027   // in the HII database
2028   //
2029   NewString = L"700 Mhz";
2030
2031   if (HiiSetString (HiiHandle[0], STRING_TOKEN (STR_CPU_STRING2), NewString, NULL) == 0) {
2032     DriverSampleUnload (ImageHandle);
2033     return EFI_OUT_OF_RESOURCES;
2034   }
2035
2036   HiiSetString (HiiHandle[0], 0, NewString, NULL);
2037
2038   //
2039   // Initialize Name/Value name String ID
2040   //
2041   PrivateData->NameStringId[0] = STR_NAME_VALUE_VAR_NAME0;
2042   PrivateData->NameStringId[1] = STR_NAME_VALUE_VAR_NAME1;
2043   PrivateData->NameStringId[2] = STR_NAME_VALUE_VAR_NAME2;
2044
2045   //
2046   // Initialize configuration data
2047   //
2048   Configuration = &PrivateData->Configuration;
2049   ZeroMem (Configuration, sizeof (DRIVER_SAMPLE_CONFIGURATION));
2050
2051   //
2052   // Try to read NV config EFI variable first
2053   //
2054   ConfigRequestHdr = HiiConstructConfigHdr (&gDriverSampleFormSetGuid, VariableName, DriverHandle[0]);
2055   ASSERT (ConfigRequestHdr != NULL);
2056
2057   NameRequestHdr = HiiConstructConfigHdr (&gDriverSampleFormSetGuid, NULL, DriverHandle[0]);
2058   ASSERT (NameRequestHdr != NULL);
2059
2060   BufferSize = sizeof (DRIVER_SAMPLE_CONFIGURATION);
2061   Status = gRT->GetVariable (VariableName, &gDriverSampleFormSetGuid, NULL, &BufferSize, Configuration);
2062   if (EFI_ERROR (Status)) {
2063     //
2064     // Store zero data Buffer Storage to EFI variable
2065     //
2066     Status = gRT->SetVariable(
2067                     VariableName,
2068                     &gDriverSampleFormSetGuid,
2069                     EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
2070                     sizeof (DRIVER_SAMPLE_CONFIGURATION),
2071                     Configuration
2072                     );
2073     if (EFI_ERROR (Status)) {
2074       DriverSampleUnload (ImageHandle);
2075       return Status;
2076     }
2077     //
2078     // EFI variable for NV config doesn't exit, we should build this variable
2079     // based on default values stored in IFR
2080     //
2081     ActionFlag = HiiSetToDefaults (NameRequestHdr, EFI_HII_DEFAULT_CLASS_STANDARD);
2082     if (!ActionFlag) {
2083       DriverSampleUnload (ImageHandle);
2084       return EFI_INVALID_PARAMETER;
2085     }
2086
2087     ActionFlag = HiiSetToDefaults (ConfigRequestHdr, EFI_HII_DEFAULT_CLASS_STANDARD);
2088     if (!ActionFlag) {
2089       DriverSampleUnload (ImageHandle);
2090       return EFI_INVALID_PARAMETER;
2091     }
2092   } else {
2093     //
2094     // EFI variable does exist and Validate Current Setting
2095     //
2096     ActionFlag = HiiValidateSettings (NameRequestHdr);
2097     if (!ActionFlag) {
2098       DriverSampleUnload (ImageHandle);
2099       return EFI_INVALID_PARAMETER;
2100     }
2101
2102     ActionFlag = HiiValidateSettings (ConfigRequestHdr);
2103     if (!ActionFlag) {
2104       DriverSampleUnload (ImageHandle);
2105       return EFI_INVALID_PARAMETER;
2106     }
2107   }
2108   FreePool (ConfigRequestHdr);
2109
2110   //
2111   // Initialize efi varstore configuration data
2112   //
2113   VarStoreConfig = &PrivateData->VarStoreConfig;
2114   ZeroMem (VarStoreConfig, sizeof (MY_EFI_VARSTORE_DATA));
2115
2116   ConfigRequestHdr = HiiConstructConfigHdr (&gDriverSampleFormSetGuid, MyEfiVar, DriverHandle[0]);
2117   ASSERT (ConfigRequestHdr != NULL);
2118
2119   BufferSize = sizeof (MY_EFI_VARSTORE_DATA);
2120   Status = gRT->GetVariable (MyEfiVar, &gDriverSampleFormSetGuid, NULL, &BufferSize, VarStoreConfig);
2121   if (EFI_ERROR (Status)) {
2122     //
2123     // Store zero data to EFI variable Storage.
2124     //
2125     Status = gRT->SetVariable(
2126                     MyEfiVar,
2127                     &gDriverSampleFormSetGuid,
2128                     EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
2129                     sizeof (MY_EFI_VARSTORE_DATA),
2130                     VarStoreConfig
2131                     );
2132     if (EFI_ERROR (Status)) {
2133       DriverSampleUnload (ImageHandle);
2134       return Status;
2135     }
2136     //
2137     // EFI variable for NV config doesn't exit, we should build this variable
2138     // based on default values stored in IFR
2139     //
2140     ActionFlag = HiiSetToDefaults (ConfigRequestHdr, EFI_HII_DEFAULT_CLASS_STANDARD);
2141     if (!ActionFlag) {
2142       DriverSampleUnload (ImageHandle);
2143       return EFI_INVALID_PARAMETER;
2144     }
2145   } else {
2146     //
2147     // EFI variable does exist and Validate Current Setting
2148     //
2149     ActionFlag = HiiValidateSettings (ConfigRequestHdr);
2150     if (!ActionFlag) {
2151       DriverSampleUnload (ImageHandle);
2152       return EFI_INVALID_PARAMETER;
2153     }
2154   }
2155   FreePool (ConfigRequestHdr);
2156
2157   Status = gBS->CreateEventEx (
2158         EVT_NOTIFY_SIGNAL,
2159         TPL_NOTIFY,
2160         DriverSampleInternalEmptyFunction,
2161         NULL,
2162         &gEfiIfrRefreshIdOpGuid,
2163         &mEvent
2164         );
2165   ASSERT_EFI_ERROR (Status);
2166
2167   //
2168   // Example of how to use BrowserEx protocol to register HotKey.
2169   //
2170   Status = gBS->LocateProtocol (&gEfiFormBrowserExProtocolGuid, NULL, (VOID **) &FormBrowserEx);
2171   if (!EFI_ERROR (Status)) {
2172     //
2173     // First unregister the default hot key F9 and F10.
2174     //
2175     HotKey.UnicodeChar = CHAR_NULL;
2176     HotKey.ScanCode    = SCAN_F9;
2177     FormBrowserEx->RegisterHotKey (&HotKey, 0, 0, NULL);
2178     HotKey.ScanCode    = SCAN_F10;
2179     FormBrowserEx->RegisterHotKey (&HotKey, 0, 0, NULL);
2180
2181     //
2182     // Register the default HotKey F9 and F10 again.
2183     //
2184     HotKey.ScanCode   = SCAN_F10;
2185     NewString         = HiiGetString (PrivateData->HiiHandle[0], STRING_TOKEN (FUNCTION_TEN_STRING), NULL);
2186     ASSERT (NewString != NULL);
2187     FormBrowserEx->RegisterHotKey (&HotKey, BROWSER_ACTION_SUBMIT, 0, NewString);
2188     HotKey.ScanCode   = SCAN_F9;
2189     NewString         = HiiGetString (PrivateData->HiiHandle[0], STRING_TOKEN (FUNCTION_NINE_STRING), NULL);
2190     ASSERT (NewString != NULL);
2191     FormBrowserEx->RegisterHotKey (&HotKey, BROWSER_ACTION_DEFAULT, EFI_HII_DEFAULT_CLASS_STANDARD, NewString);
2192   }
2193
2194   //
2195   // In default, this driver is built into Flash device image,
2196   // the following code doesn't run.
2197   //
2198
2199   //
2200   // Example of how to display only the item we sent to HII
2201   // When this driver is not built into Flash device image,
2202   // it need to call SendForm to show front page by itself.
2203   //
2204   if (DISPLAY_ONLY_MY_ITEM <= 1) {
2205     //
2206     // Have the browser pull out our copy of the data, and only display our data
2207     //
2208     Status = FormBrowser2->SendForm (
2209                              FormBrowser2,
2210                              &(HiiHandle[DISPLAY_ONLY_MY_ITEM]),
2211                              1,
2212                              NULL,
2213                              0,
2214                              NULL,
2215                              NULL
2216                              );
2217
2218     HiiRemovePackages (HiiHandle[0]);
2219
2220     HiiRemovePackages (HiiHandle[1]);
2221   }
2222
2223   return EFI_SUCCESS;
2224 }
2225
2226 /**
2227   Unloads the application and its installed protocol.
2228
2229   @param[in]  ImageHandle       Handle that identifies the image to be unloaded.
2230
2231   @retval EFI_SUCCESS           The image has been unloaded.
2232 **/
2233 EFI_STATUS
2234 EFIAPI
2235 DriverSampleUnload (
2236   IN EFI_HANDLE  ImageHandle
2237   )
2238 {
2239   UINTN Index;
2240
2241   ASSERT (PrivateData != NULL);
2242
2243   if (DriverHandle[0] != NULL) {
2244     gBS->UninstallMultipleProtocolInterfaces (
2245             DriverHandle[0],
2246             &gEfiDevicePathProtocolGuid,
2247             &mHiiVendorDevicePath0,
2248             &gEfiHiiConfigAccessProtocolGuid,
2249             &PrivateData->ConfigAccess,
2250             NULL
2251            );
2252     DriverHandle[0] = NULL;
2253   }
2254
2255   if (DriverHandle[1] != NULL) {
2256     gBS->UninstallMultipleProtocolInterfaces (
2257             DriverHandle[1],
2258             &gEfiDevicePathProtocolGuid,
2259             &mHiiVendorDevicePath1,
2260             NULL
2261            );
2262     DriverHandle[1] = NULL;
2263   }
2264
2265   if (PrivateData->HiiHandle[0] != NULL) {
2266     HiiRemovePackages (PrivateData->HiiHandle[0]);
2267   }
2268
2269   if (PrivateData->HiiHandle[1] != NULL) {
2270     HiiRemovePackages (PrivateData->HiiHandle[1]);
2271   }
2272
2273   for (Index = 0; Index < NAME_VALUE_NAME_NUMBER; Index++) {
2274     if (PrivateData->NameValueName[Index] != NULL) {
2275       FreePool (PrivateData->NameValueName[Index]);
2276     }
2277   }
2278   FreePool (PrivateData);
2279   PrivateData = NULL;
2280
2281   gBS->CloseEvent (mEvent);
2282
2283   return EFI_SUCCESS;
2284 }