1 /** @file 2 HII Config Access protocol implementation of RamDiskDxe driver. 3 4 Copyright (c) 2016, Intel Corporation. All rights reserved.<BR> 5 (C) Copyright 2016 Hewlett Packard Enterprise Development LP<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 #include "RamDiskImpl.h" 17 18 CHAR16 mRamDiskStorageName[] = L"RAM_DISK_CONFIGURATION"; 19 20 RAM_DISK_CONFIG_PRIVATE_DATA mRamDiskConfigPrivateDataTemplate = { 21 RAM_DISK_CONFIG_PRIVATE_DATA_SIGNATURE, 22 { 23 EFI_PAGE_SIZE, 24 RAM_DISK_BOOT_SERVICE_DATA_MEMORY 25 }, 26 { 27 RamDiskExtractConfig, 28 RamDiskRouteConfig, 29 RamDiskCallback 30 } 31 }; 32 33 HII_VENDOR_DEVICE_PATH mRamDiskHiiVendorDevicePath = { 34 { 35 { 36 HARDWARE_DEVICE_PATH, 37 HW_VENDOR_DP, 38 { 39 (UINT8) (sizeof (VENDOR_DEVICE_PATH)), 40 (UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8) 41 } 42 }, 43 RAM_DISK_FORM_SET_GUID 44 }, 45 { 46 END_DEVICE_PATH_TYPE, 47 END_ENTIRE_DEVICE_PATH_SUBTYPE, 48 { 49 (UINT8) (END_DEVICE_PATH_LENGTH), 50 (UINT8) ((END_DEVICE_PATH_LENGTH) >> 8) 51 } 52 } 53 }; 54 55 56 /** 57 This function publish the RAM disk configuration Form. 58 59 @param[in, out] ConfigPrivateData 60 Points to RAM disk configuration private data. 61 62 @retval EFI_SUCCESS HII Form is installed successfully. 63 @retval EFI_OUT_OF_RESOURCES Not enough resource for HII Form installation. 64 @retval Others Other errors as indicated. 65 66 **/ 67 EFI_STATUS 68 InstallRamDiskConfigForm ( 69 IN OUT RAM_DISK_CONFIG_PRIVATE_DATA *ConfigPrivateData 70 ) 71 { 72 EFI_STATUS Status; 73 EFI_HII_HANDLE HiiHandle; 74 EFI_HANDLE DriverHandle; 75 EFI_HII_CONFIG_ACCESS_PROTOCOL *ConfigAccess; 76 77 DriverHandle = NULL; 78 ConfigAccess = &ConfigPrivateData->ConfigAccess; 79 Status = gBS->InstallMultipleProtocolInterfaces ( 80 &DriverHandle, 81 &gEfiDevicePathProtocolGuid, 82 &mRamDiskHiiVendorDevicePath, 83 &gEfiHiiConfigAccessProtocolGuid, 84 ConfigAccess, 85 NULL 86 ); 87 if (EFI_ERROR (Status)) { 88 return Status; 89 } 90 91 ConfigPrivateData->DriverHandle = DriverHandle; 92 93 // 94 // Publish the HII package list 95 // 96 HiiHandle = HiiAddPackages ( 97 &gRamDiskFormSetGuid, 98 DriverHandle, 99 RamDiskDxeStrings, 100 RamDiskHiiBin, 101 NULL 102 ); 103 if (HiiHandle == NULL) { 104 gBS->UninstallMultipleProtocolInterfaces ( 105 DriverHandle, 106 &gEfiDevicePathProtocolGuid, 107 &mRamDiskHiiVendorDevicePath, 108 &gEfiHiiConfigAccessProtocolGuid, 109 ConfigAccess, 110 NULL 111 ); 112 return EFI_OUT_OF_RESOURCES; 113 } 114 115 ConfigPrivateData->HiiHandle = HiiHandle; 116 117 return EFI_SUCCESS; 118 } 119 120 121 /** 122 This function removes RAM disk configuration Form. 123 124 @param[in, out] ConfigPrivateData 125 Points to RAM disk configuration private data. 126 127 **/ 128 VOID 129 UninstallRamDiskConfigForm ( 130 IN OUT RAM_DISK_CONFIG_PRIVATE_DATA *ConfigPrivateData 131 ) 132 { 133 // 134 // Uninstall HII package list 135 // 136 if (ConfigPrivateData->HiiHandle != NULL) { 137 HiiRemovePackages (ConfigPrivateData->HiiHandle); 138 ConfigPrivateData->HiiHandle = NULL; 139 } 140 141 // 142 // Uninstall HII Config Access Protocol 143 // 144 if (ConfigPrivateData->DriverHandle != NULL) { 145 gBS->UninstallMultipleProtocolInterfaces ( 146 ConfigPrivateData->DriverHandle, 147 &gEfiDevicePathProtocolGuid, 148 &mRamDiskHiiVendorDevicePath, 149 &gEfiHiiConfigAccessProtocolGuid, 150 &ConfigPrivateData->ConfigAccess, 151 NULL 152 ); 153 ConfigPrivateData->DriverHandle = NULL; 154 } 155 156 FreePool (ConfigPrivateData); 157 } 158 159 160 /** 161 Unregister all registered RAM disks. 162 163 **/ 164 VOID 165 UnregisterAllRamDisks ( 166 VOID 167 ) 168 { 169 LIST_ENTRY *Entry; 170 LIST_ENTRY *NextEntry; 171 RAM_DISK_PRIVATE_DATA *PrivateData; 172 173 if (!IsListEmpty(&RegisteredRamDisks)) { 174 EFI_LIST_FOR_EACH_SAFE (Entry, NextEntry, &RegisteredRamDisks) { 175 PrivateData = RAM_DISK_PRIVATE_FROM_THIS (Entry); 176 177 gBS->UninstallMultipleProtocolInterfaces ( 178 PrivateData->Handle, 179 &gEfiBlockIoProtocolGuid, 180 &PrivateData->BlockIo, 181 &gEfiBlockIo2ProtocolGuid, 182 &PrivateData->BlockIo2, 183 &gEfiDevicePathProtocolGuid, 184 (EFI_DEVICE_PATH_PROTOCOL *) PrivateData->DevicePath, 185 NULL 186 ); 187 188 RemoveEntryList (&PrivateData->ThisInstance); 189 190 if (RamDiskCreateHii == PrivateData->CreateMethod) { 191 // 192 // If a RAM disk is created within HII, then the RamDiskDxe driver 193 // driver is responsible for freeing the allocated memory for the 194 // RAM disk. 195 // 196 FreePool ((VOID *)(UINTN) PrivateData->StartingAddr); 197 } 198 199 FreePool (PrivateData->DevicePath); 200 FreePool (PrivateData); 201 } 202 } 203 } 204 205 206 /** 207 This function allows a caller to extract the current configuration for one 208 or more named elements from the target driver. 209 210 @param[in] This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL. 211 @param[in] Request A null-terminated Unicode string in 212 <ConfigRequest> format. 213 @param[out] Progress On return, points to a character in the Request 214 string. Points to the string's null terminator if 215 request was successful. Points to the most recent 216 '&' before the first failing name/value pair (or 217 the beginning of the string if the failure is in 218 the first name/value pair) if the request was not 219 successful. 220 @param[out] Results A null-terminated Unicode string in 221 <ConfigAltResp> format which has all values filled 222 in for the names in the Request string. String to 223 be allocated by the called function. 224 225 @retval EFI_SUCCESS The Results is filled with the requested 226 values. 227 @retval EFI_OUT_OF_RESOURCES Not enough memory to store the results. 228 @retval EFI_INVALID_PARAMETER Request is illegal syntax, or unknown name. 229 @retval EFI_NOT_FOUND Routing data doesn't match any storage in 230 this driver. 231 232 **/ 233 EFI_STATUS 234 EFIAPI 235 RamDiskExtractConfig ( 236 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This, 237 IN CONST EFI_STRING Request, 238 OUT EFI_STRING *Progress, 239 OUT EFI_STRING *Results 240 ) 241 { 242 if (Progress == NULL || Results == NULL) { 243 return EFI_INVALID_PARAMETER; 244 } 245 *Progress = Request; 246 return EFI_NOT_FOUND; 247 } 248 249 250 /** 251 This function processes the results of changes in configuration. 252 253 @param[in] This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL. 254 @param[in] Configuration A null-terminated Unicode string in <ConfigResp> 255 format. 256 @param[out] Progress A pointer to a string filled in with the offset of 257 the most recent '&' before the first failing 258 name/value pair (or the beginning of the string if 259 the failure is in the first name/value pair) or 260 the terminating NULL if all was successful. 261 262 @retval EFI_SUCCESS The Results is processed successfully. 263 @retval EFI_INVALID_PARAMETER Configuration is NULL. 264 @retval EFI_NOT_FOUND Routing data doesn't match any storage in 265 this driver. 266 267 **/ 268 EFI_STATUS 269 EFIAPI 270 RamDiskRouteConfig ( 271 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This, 272 IN CONST EFI_STRING Configuration, 273 OUT EFI_STRING *Progress 274 ) 275 { 276 if (Configuration == NULL || Progress == NULL) { 277 return EFI_INVALID_PARAMETER; 278 } 279 280 return EFI_NOT_FOUND; 281 } 282 283 284 /** 285 Allocate memory and register the RAM disk created within RamDiskDxe 286 driver HII. 287 288 @param[in] Size If creating raw, size of the RAM disk to create. 289 If creating from file, zero. 290 @param[in] FileHandle If creating raw, NULL. If creating from file, the 291 file handle. 292 @param[in] MemoryType Type of memory to be used to create RAM Disk. 293 294 @retval EFI_SUCCESS RAM disk is created and registered. 295 @retval EFI_OUT_OF_RESOURCES Not enough storage is available to match the 296 size required. 297 298 **/ 299 EFI_STATUS 300 HiiCreateRamDisk ( 301 IN UINT64 Size, 302 IN EFI_FILE_HANDLE FileHandle, 303 IN UINT8 MemoryType 304 ) 305 { 306 EFI_STATUS Status; 307 UINTN BufferSize; 308 UINT64 *StartingAddr; 309 EFI_INPUT_KEY Key; 310 EFI_DEVICE_PATH_PROTOCOL *DevicePath; 311 RAM_DISK_PRIVATE_DATA *PrivateData; 312 EFI_FILE_INFO *FileInformation; 313 314 FileInformation = NULL; 315 StartingAddr = NULL; 316 317 if (FileHandle != NULL) { 318 // 319 // Create from file. 320 // 321 FileInformation = FileInfo (FileHandle); 322 if (NULL == FileInformation) { 323 do { 324 CreatePopUp ( 325 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, 326 &Key, 327 L"", 328 L"Not enough memory to get the file information!", 329 L"Press ENTER to continue ...", 330 L"", 331 NULL 332 ); 333 } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN); 334 335 return EFI_OUT_OF_RESOURCES; 336 } 337 338 // 339 // Update the size of RAM disk according to the file size. 340 // 341 Size = FileInformation->FileSize; 342 } 343 344 if (Size > (UINTN) -1) { 345 do { 346 CreatePopUp ( 347 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, 348 &Key, 349 L"", 350 L"The given RAM disk size is too large!", 351 L"Press ENTER to continue ...", 352 L"", 353 NULL 354 ); 355 } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN); 356 357 return EFI_OUT_OF_RESOURCES; 358 } 359 360 if (MemoryType == RAM_DISK_BOOT_SERVICE_DATA_MEMORY) { 361 Status = gBS->AllocatePool ( 362 EfiBootServicesData, 363 (UINTN)Size, 364 (VOID**)&StartingAddr 365 ); 366 } else if (MemoryType == RAM_DISK_RESERVED_MEMORY) { 367 Status = gBS->AllocatePool ( 368 EfiReservedMemoryType, 369 (UINTN)Size, 370 (VOID**)&StartingAddr 371 ); 372 } else { 373 Status = EFI_INVALID_PARAMETER; 374 } 375 376 if ((StartingAddr == NULL) || EFI_ERROR(Status)) { 377 do { 378 CreatePopUp ( 379 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, 380 &Key, 381 L"", 382 L"Not enough memory to create the RAM disk!", 383 L"Press ENTER to continue ...", 384 L"", 385 NULL 386 ); 387 } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN); 388 389 return EFI_OUT_OF_RESOURCES; 390 } 391 392 if (FileHandle != NULL) { 393 // 394 // Copy the file content to the RAM disk. 395 // 396 BufferSize = (UINTN) Size; 397 FileHandle->Read ( 398 FileHandle, 399 &BufferSize, 400 (VOID *)(UINTN) StartingAddr 401 ); 402 if (BufferSize != FileInformation->FileSize) { 403 do { 404 CreatePopUp ( 405 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, 406 &Key, 407 L"", 408 L"File content read error!", 409 L"Press ENTER to continue ...", 410 L"", 411 NULL 412 ); 413 } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN); 414 415 return EFI_DEVICE_ERROR; 416 } 417 } 418 419 // 420 // Register the newly created RAM disk. 421 // 422 Status = RamDiskRegister ( 423 ((UINT64)(UINTN) StartingAddr), 424 Size, 425 &gEfiVirtualDiskGuid, 426 NULL, 427 &DevicePath 428 ); 429 if (EFI_ERROR (Status)) { 430 do { 431 CreatePopUp ( 432 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, 433 &Key, 434 L"", 435 L"Fail to register the newly created RAM disk!", 436 L"Press ENTER to continue ...", 437 L"", 438 NULL 439 ); 440 } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN); 441 442 return Status; 443 } 444 445 // 446 // If RAM disk is created within HII, memory should be freed when the 447 // RAM disk is unregisterd. 448 // 449 PrivateData = RAM_DISK_PRIVATE_FROM_THIS (RegisteredRamDisks.BackLink); 450 PrivateData->CreateMethod = RamDiskCreateHii; 451 452 return EFI_SUCCESS; 453 } 454 455 456 /** 457 This function updates the registered RAM disks list on the main form. 458 459 @param[in, out] ConfigPrivate 460 Private data for configurating hii data for RAM 461 disks. 462 463 **/ 464 VOID 465 UpdateMainForm ( 466 IN OUT RAM_DISK_CONFIG_PRIVATE_DATA *ConfigPrivate 467 ) 468 { 469 VOID *StartOpCodeHandle; 470 VOID *EndOpCodeHandle; 471 EFI_IFR_GUID_LABEL *StartLabel; 472 EFI_IFR_GUID_LABEL *EndLabel; 473 LIST_ENTRY *Entry; 474 UINTN Index; 475 RAM_DISK_PRIVATE_DATA *PrivateData; 476 CHAR16 *String; 477 CHAR16 RamDiskStr[128]; 478 EFI_STRING_ID StringId; 479 480 // 481 // Init OpCode Handle 482 // 483 StartOpCodeHandle = HiiAllocateOpCodeHandle (); 484 ASSERT (StartOpCodeHandle != NULL); 485 486 EndOpCodeHandle = HiiAllocateOpCodeHandle (); 487 ASSERT (EndOpCodeHandle != NULL); 488 489 // 490 // Create Hii Extend Label OpCode as the start opcode 491 // 492 StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode ( 493 StartOpCodeHandle, 494 &gEfiIfrTianoGuid, 495 NULL, 496 sizeof (EFI_IFR_GUID_LABEL) 497 ); 498 StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL; 499 StartLabel->Number = MAIN_LABEL_LIST_START; 500 501 // 502 // Create Hii Extend Label OpCode as the end opcode 503 // 504 EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode ( 505 EndOpCodeHandle, 506 &gEfiIfrTianoGuid, 507 NULL, 508 sizeof (EFI_IFR_GUID_LABEL) 509 ); 510 EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL; 511 EndLabel->Number = MAIN_LABEL_LIST_END; 512 513 Index = 0; 514 EFI_LIST_FOR_EACH (Entry, &RegisteredRamDisks) { 515 PrivateData = RAM_DISK_PRIVATE_FROM_THIS (Entry); 516 PrivateData->CheckBoxId = (EFI_QUESTION_ID) 517 (MAIN_CHECKBOX_QUESTION_ID_START + Index); 518 // 519 // CheckBox is unchecked by default. 520 // 521 PrivateData->CheckBoxChecked = FALSE; 522 String = RamDiskStr; 523 524 UnicodeSPrint ( 525 String, 526 sizeof (RamDiskStr), 527 L" RAM Disk %d: [0x%lx, 0x%lx]\n", 528 Index, 529 PrivateData->StartingAddr, 530 PrivateData->StartingAddr + PrivateData->Size - 1 531 ); 532 533 StringId = HiiSetString (ConfigPrivate->HiiHandle, 0, RamDiskStr, NULL); 534 ASSERT (StringId != 0); 535 536 HiiCreateCheckBoxOpCode ( 537 StartOpCodeHandle, 538 PrivateData->CheckBoxId, 539 0, 540 0, 541 StringId, 542 STRING_TOKEN (STR_RAM_DISK_LIST_HELP), 543 EFI_IFR_FLAG_CALLBACK, 544 0, 545 NULL 546 ); 547 548 Index++; 549 } 550 551 HiiUpdateForm ( 552 ConfigPrivate->HiiHandle, 553 &gRamDiskFormSetGuid, 554 MAIN_FORM_ID, 555 StartOpCodeHandle, 556 EndOpCodeHandle 557 ); 558 559 HiiFreeOpCodeHandle (StartOpCodeHandle); 560 HiiFreeOpCodeHandle (EndOpCodeHandle); 561 } 562 563 564 /** 565 This function processes the results of changes in configuration. 566 567 @param[in] This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL. 568 @param[in] Action Specifies the type of action taken by the browser. 569 @param[in] QuestionId A unique value which is sent to the original 570 exporting driver so that it can identify the type 571 of data to expect. 572 @param[in] Type The type of value for the question. 573 @param[in] Value A pointer to the data being sent to the original 574 exporting driver. 575 @param[out] ActionRequest On return, points to the action requested by the 576 callback function. 577 578 @retval EFI_SUCCESS The callback successfully handled the action. 579 @retval EFI_OUT_OF_RESOURCES Not enough storage is available to hold the 580 variable and its data. 581 @retval EFI_DEVICE_ERROR The variable could not be saved. 582 @retval EFI_UNSUPPORTED The specified Action is not supported by the 583 callback. 584 585 **/ 586 EFI_STATUS 587 EFIAPI 588 RamDiskCallback ( 589 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This, 590 IN EFI_BROWSER_ACTION Action, 591 IN EFI_QUESTION_ID QuestionId, 592 IN UINT8 Type, 593 IN EFI_IFR_TYPE_VALUE *Value, 594 OUT EFI_BROWSER_ACTION_REQUEST *ActionRequest 595 ) 596 { 597 EFI_STATUS Status; 598 RAM_DISK_PRIVATE_DATA *PrivateData; 599 RAM_DISK_CONFIG_PRIVATE_DATA *ConfigPrivate; 600 EFI_DEVICE_PATH_PROTOCOL *FileDevPath; 601 EFI_FILE_HANDLE FileHandle; 602 LIST_ENTRY *Entry; 603 LIST_ENTRY *NextEntry; 604 605 if ((This == NULL) || (Value == NULL) || (ActionRequest == NULL)) { 606 return EFI_INVALID_PARAMETER; 607 } 608 609 ConfigPrivate = RAM_DISK_CONFIG_PRIVATE_FROM_THIS (This); 610 611 if (Action == EFI_BROWSER_ACTION_RETRIEVE) { 612 Status = EFI_UNSUPPORTED; 613 if (QuestionId == CREATE_RAW_SIZE_QUESTION_ID) { 614 Value->u64 = EFI_PAGE_SIZE; 615 ConfigPrivate->ConfigStore.Size = EFI_PAGE_SIZE; 616 Status = EFI_SUCCESS; 617 } else if (QuestionId == CREATE_RAW_MEMORY_TYPE_QUESTION_ID) { 618 Value->u8 = RAM_DISK_BOOT_SERVICE_DATA_MEMORY; 619 ConfigPrivate->ConfigStore.MemType = RAM_DISK_BOOT_SERVICE_DATA_MEMORY; 620 Status = EFI_SUCCESS; 621 } 622 return Status; 623 } 624 625 if ((Action != EFI_BROWSER_ACTION_CHANGED) && 626 (Action != EFI_BROWSER_ACTION_CHANGING) && 627 (Action != EFI_BROWSER_ACTION_FORM_OPEN)) { 628 return EFI_UNSUPPORTED; 629 } 630 631 // 632 // Update the RAM disk list show at the main form first. 633 // 634 if (Action == EFI_BROWSER_ACTION_FORM_OPEN) { 635 Status = EFI_UNSUPPORTED; 636 if (QuestionId == MAIN_GOTO_FILE_EXPLORER_ID) { 637 UpdateMainForm (ConfigPrivate); 638 Status = EFI_SUCCESS; 639 } 640 return Status; 641 } 642 643 Status = EFI_SUCCESS; 644 645 if (Action == EFI_BROWSER_ACTION_CHANGING) { 646 switch (QuestionId) { 647 case MAIN_GOTO_FILE_EXPLORER_ID: 648 Status = ChooseFile (NULL, NULL, NULL, &FileDevPath); 649 if (EFI_ERROR (Status)) { 650 break; 651 } 652 653 if (FileDevPath != NULL) { 654 // 655 // Open the file. 656 // 657 Status = OpenFileByDevicePath ( 658 &FileDevPath, 659 &FileHandle, 660 EFI_FILE_MODE_READ, 661 0 662 ); 663 if (EFI_ERROR (Status)) { 664 break; 665 } 666 667 // 668 // Create from file, RAM disk size is zero. It will be updated 669 // according to the file size. 670 // 671 Status = HiiCreateRamDisk ( 672 0, 673 FileHandle, 674 ConfigPrivate->ConfigStore.MemType 675 ); 676 if (EFI_ERROR (Status)) { 677 break; 678 } 679 680 // 681 // Refresh the registered RAM disks list. 682 // 683 UpdateMainForm (ConfigPrivate); 684 } 685 break; 686 687 default: 688 break; 689 } 690 } else if (Action == EFI_BROWSER_ACTION_CHANGED) { 691 switch (QuestionId) { 692 case MAIN_REMOVE_RD_QUESTION_ID: 693 // 694 // Remove the selected RAM disks 695 // 696 EFI_LIST_FOR_EACH_SAFE (Entry, NextEntry, &RegisteredRamDisks) { 697 PrivateData = RAM_DISK_PRIVATE_FROM_THIS (Entry); 698 if (PrivateData->CheckBoxChecked) { 699 RamDiskUnregister ( 700 (EFI_DEVICE_PATH_PROTOCOL *) PrivateData->DevicePath 701 ); 702 } 703 } 704 705 UpdateMainForm (ConfigPrivate); 706 707 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_APPLY; 708 break; 709 710 case CREATE_RAW_SIZE_QUESTION_ID: 711 ConfigPrivate->ConfigStore.Size = Value->u64; 712 break; 713 714 case CREATE_RAW_MEMORY_TYPE_QUESTION_ID: 715 ConfigPrivate->ConfigStore.MemType = Value->u8; 716 break; 717 718 case CREATE_RAW_SUBMIT_QUESTION_ID: 719 // 720 // Create raw, FileHandle is NULL. 721 // 722 Status = HiiCreateRamDisk ( 723 ConfigPrivate->ConfigStore.Size, 724 NULL, 725 ConfigPrivate->ConfigStore.MemType 726 ); 727 if (EFI_ERROR (Status)) { 728 break; 729 } 730 731 // 732 // Refresh the registered RAM disks list. 733 // 734 UpdateMainForm (ConfigPrivate); 735 736 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_DISCARD_EXIT; 737 break; 738 739 case CREATE_RAW_DISCARD_QUESTION_ID: 740 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_DISCARD_EXIT; 741 break; 742 743 default: 744 // 745 // QuestionIds for checkboxes 746 // 747 if ((QuestionId >= MAIN_CHECKBOX_QUESTION_ID_START) && 748 (QuestionId < CREATE_RAW_RAM_DISK_FORM_ID)) { 749 EFI_LIST_FOR_EACH (Entry, &RegisteredRamDisks) { 750 PrivateData = RAM_DISK_PRIVATE_FROM_THIS (Entry); 751 if (PrivateData->CheckBoxId == QuestionId) { 752 PrivateData->CheckBoxChecked = (BOOLEAN) (Value->u8 != 0); 753 } 754 } 755 } 756 break; 757 } 758 } 759 760 return EFI_SUCCESS; 761 } 762
