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