1 /** @file 2 The functions for Boot Maintainence Main menu. 3 4 Copyright (c) 2004 - 2015, Intel Corporation. All rights reserved.<BR> 5 This program and the accompanying materials 6 are licensed and made available under the terms and conditions of the BSD License 7 which accompanies this distribution. The full text of the license may be found at 8 http://opensource.org/licenses/bsd-license.php 9 10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 12 13 **/ 14 15 #include "BootMaint.h" 16 #include "FormGuid.h" 17 #include "Bds.h" 18 #include "FrontPage.h" 19 20 EFI_DEVICE_PATH_PROTOCOL EndDevicePath[] = { 21 { 22 END_DEVICE_PATH_TYPE, 23 END_ENTIRE_DEVICE_PATH_SUBTYPE, 24 { 25 END_DEVICE_PATH_LENGTH, 26 0 27 } 28 } 29 }; 30 31 HII_VENDOR_DEVICE_PATH mBmmHiiVendorDevicePath = { 32 { 33 { 34 HARDWARE_DEVICE_PATH, 35 HW_VENDOR_DP, 36 { 37 (UINT8) (sizeof (VENDOR_DEVICE_PATH)), 38 (UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8) 39 } 40 }, 41 BOOT_MAINT_FORMSET_GUID 42 }, 43 { 44 END_DEVICE_PATH_TYPE, 45 END_ENTIRE_DEVICE_PATH_SUBTYPE, 46 { 47 (UINT8) (END_DEVICE_PATH_LENGTH), 48 (UINT8) ((END_DEVICE_PATH_LENGTH) >> 8) 49 } 50 } 51 }; 52 53 HII_VENDOR_DEVICE_PATH mFeHiiVendorDevicePath = { 54 { 55 { 56 HARDWARE_DEVICE_PATH, 57 HW_VENDOR_DP, 58 { 59 (UINT8) (sizeof (VENDOR_DEVICE_PATH)), 60 (UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8) 61 } 62 }, 63 FILE_EXPLORE_FORMSET_GUID 64 }, 65 { 66 END_DEVICE_PATH_TYPE, 67 END_ENTIRE_DEVICE_PATH_SUBTYPE, 68 { 69 (UINT8) (END_DEVICE_PATH_LENGTH), 70 (UINT8) ((END_DEVICE_PATH_LENGTH) >> 8) 71 } 72 } 73 }; 74 75 CHAR16 mBootMaintStorageName[] = L"BmmData"; 76 CHAR16 mFileExplorerStorageName[] = L"FeData"; 77 BMM_CALLBACK_DATA *mBmmCallbackInfo = NULL; 78 79 /** 80 Init all memu. 81 82 @param CallbackData The BMM context data. 83 84 **/ 85 VOID 86 InitAllMenu ( 87 IN BMM_CALLBACK_DATA *CallbackData 88 ); 89 90 /** 91 Free up all Menu Option list. 92 93 **/ 94 VOID 95 FreeAllMenu ( 96 VOID 97 ); 98 99 /** 100 Initialize all of BMM configuration data in BmmFakeNvData and BmmOldFakeNVData member 101 in BMM context data and create all of dynamic OP code for BMM. 102 103 @param CallbackData The BMM context data. 104 105 **/ 106 VOID 107 InitializeBmmConfig ( 108 IN BMM_CALLBACK_DATA *CallbackData 109 ) 110 { 111 BM_MENU_ENTRY *NewMenuEntry; 112 BM_LOAD_CONTEXT *NewLoadContext; 113 UINT16 Index; 114 115 ASSERT (CallbackData != NULL); 116 117 // 118 // Initialize data which located in BMM main page 119 // 120 CallbackData->BmmFakeNvData.BootNext = (UINT16) (BootOptionMenu.MenuNumber); 121 for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) { 122 NewMenuEntry = BOpt_GetMenuEntry (&BootOptionMenu, Index); 123 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext; 124 125 if (NewLoadContext->IsBootNext) { 126 CallbackData->BmmFakeNvData.BootNext = Index; 127 break; 128 } 129 } 130 131 CallbackData->BmmFakeNvData.BootTimeOut = PcdGet16 (PcdPlatformBootTimeOut); 132 133 // 134 // Initialize data which located in Boot Options Menu 135 // 136 GetBootOrder (CallbackData); 137 GetLegacyDeviceOrder (CallbackData); 138 139 // 140 // Initialize data which located in Driver Options Menu 141 // 142 GetDriverOrder (CallbackData); 143 144 // 145 // Initialize data which located in Console Options Menu 146 // 147 GetConsoleOutMode (CallbackData); 148 GetConsoleInCheck (CallbackData); 149 GetConsoleOutCheck (CallbackData); 150 GetConsoleErrCheck (CallbackData); 151 GetTerminalAttribute (CallbackData); 152 153 // 154 // Backup Initialize BMM configuartion data to BmmOldFakeNVData 155 // 156 CopyMem (&CallbackData->BmmOldFakeNVData, &CallbackData->BmmFakeNvData, sizeof (BMM_FAKE_NV_DATA)); 157 } 158 159 /** 160 Create string tokens for a menu from its help strings and display strings 161 162 @param CallbackData The BMM context data. 163 @param HiiHandle Hii Handle of the package to be updated. 164 @param MenuOption The Menu whose string tokens need to be created 165 166 @retval EFI_SUCCESS String tokens created successfully 167 @retval others contain some errors 168 **/ 169 EFI_STATUS 170 CreateMenuStringToken ( 171 IN BMM_CALLBACK_DATA *CallbackData, 172 IN EFI_HII_HANDLE HiiHandle, 173 IN BM_MENU_OPTION *MenuOption 174 ) 175 { 176 BM_MENU_ENTRY *NewMenuEntry; 177 UINTN Index; 178 179 for (Index = 0; Index < MenuOption->MenuNumber; Index++) { 180 NewMenuEntry = BOpt_GetMenuEntry (MenuOption, Index); 181 182 NewMenuEntry->DisplayStringToken = HiiSetString ( 183 HiiHandle, 184 0, 185 NewMenuEntry->DisplayString, 186 NULL 187 ); 188 189 if (NULL == NewMenuEntry->HelpString) { 190 NewMenuEntry->HelpStringToken = NewMenuEntry->DisplayStringToken; 191 } else { 192 NewMenuEntry->HelpStringToken = HiiSetString ( 193 HiiHandle, 194 0, 195 NewMenuEntry->HelpString, 196 NULL 197 ); 198 } 199 } 200 201 return EFI_SUCCESS; 202 } 203 204 /** 205 This function allows a caller to extract the current configuration for one 206 or more named elements from the target driver. 207 208 209 @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL. 210 @param Request A null-terminated Unicode string in <ConfigRequest> format. 211 @param Progress On return, points to a character in the Request string. 212 Points to the string's null terminator if request was successful. 213 Points to the most recent '&' before the first failing name/value 214 pair (or the beginning of the string if the failure is in the 215 first name/value pair) if the request was not successful. 216 @param Results A null-terminated Unicode string in <ConfigAltResp> format which 217 has all values filled in for the names in the Request string. 218 String to be allocated by the called function. 219 220 @retval EFI_SUCCESS The Results is filled with the requested values. 221 @retval EFI_OUT_OF_RESOURCES Not enough memory to store the results. 222 @retval EFI_INVALID_PARAMETER Request is NULL, illegal syntax, or unknown name. 223 @retval EFI_NOT_FOUND Routing data doesn't match any storage in this driver. 224 225 **/ 226 EFI_STATUS 227 EFIAPI 228 BootMaintExtractConfig ( 229 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This, 230 IN CONST EFI_STRING Request, 231 OUT EFI_STRING *Progress, 232 OUT EFI_STRING *Results 233 ) 234 { 235 EFI_STATUS Status; 236 UINTN BufferSize; 237 BMM_CALLBACK_DATA *Private; 238 EFI_STRING ConfigRequestHdr; 239 EFI_STRING ConfigRequest; 240 BOOLEAN AllocatedRequest; 241 UINTN Size; 242 243 if (Progress == NULL || Results == NULL) { 244 return EFI_INVALID_PARAMETER; 245 } 246 247 *Progress = Request; 248 if ((Request != NULL) && !HiiIsConfigHdrMatch (Request, &gBootMaintFormSetGuid, mBootMaintStorageName)) { 249 return EFI_NOT_FOUND; 250 } 251 252 ConfigRequestHdr = NULL; 253 ConfigRequest = NULL; 254 AllocatedRequest = FALSE; 255 Size = 0; 256 257 Private = BMM_CALLBACK_DATA_FROM_THIS (This); 258 // 259 // Convert buffer data to <ConfigResp> by helper function BlockToConfig() 260 // 261 BufferSize = sizeof (BMM_FAKE_NV_DATA); 262 ConfigRequest = Request; 263 if ((Request == NULL) || (StrStr (Request, L"OFFSET") == NULL)) { 264 // 265 // Request has no request element, construct full request string. 266 // Allocate and fill a buffer large enough to hold the <ConfigHdr> template 267 // followed by "&OFFSET=0&WIDTH=WWWWWWWWWWWWWWWW" followed by a Null-terminator 268 // 269 ConfigRequestHdr = HiiConstructConfigHdr (&gBootMaintFormSetGuid, mBootMaintStorageName, Private->BmmDriverHandle); 270 Size = (StrLen (ConfigRequestHdr) + 32 + 1) * sizeof (CHAR16); 271 ConfigRequest = AllocateZeroPool (Size); 272 ASSERT (ConfigRequest != NULL); 273 AllocatedRequest = TRUE; 274 UnicodeSPrint (ConfigRequest, Size, L"%s&OFFSET=0&WIDTH=%016LX", ConfigRequestHdr, (UINT64)BufferSize); 275 FreePool (ConfigRequestHdr); 276 } 277 278 Status = gHiiConfigRouting->BlockToConfig ( 279 gHiiConfigRouting, 280 ConfigRequest, 281 (UINT8 *) &Private->BmmFakeNvData, 282 BufferSize, 283 Results, 284 Progress 285 ); 286 // 287 // Free the allocated config request string. 288 // 289 if (AllocatedRequest) { 290 FreePool (ConfigRequest); 291 ConfigRequest = NULL; 292 } 293 // 294 // Set Progress string to the original request string. 295 // 296 if (Request == NULL) { 297 *Progress = NULL; 298 } else if (StrStr (Request, L"OFFSET") == NULL) { 299 *Progress = Request + StrLen (Request); 300 } 301 302 return Status; 303 } 304 305 /** 306 This function applies changes in a driver's configuration. 307 Input is a Configuration, which has the routing data for this 308 driver followed by name / value configuration pairs. The driver 309 must apply those pairs to its configurable storage. If the 310 driver's configuration is stored in a linear block of data 311 and the driver's name / value pairs are in <BlockConfig> 312 format, it may use the ConfigToBlock helper function (above) to 313 simplify the job. Currently not implemented. 314 315 @param[in] This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL. 316 @param[in] Configuration A null-terminated Unicode string in 317 <ConfigString> format. 318 @param[out] Progress A pointer to a string filled in with the 319 offset of the most recent '&' before the 320 first failing name / value pair (or the 321 beginn ing of the string if the failure 322 is in the first name / value pair) or 323 the terminating NULL if all was 324 successful. 325 326 @retval EFI_SUCCESS The results have been distributed or are 327 awaiting distribution. 328 @retval EFI_OUT_OF_RESOURCES Not enough memory to store the 329 parts of the results that must be 330 stored awaiting possible future 331 protocols. 332 @retval EFI_INVALID_PARAMETERS Passing in a NULL for the 333 Results parameter would result 334 in this type of error. 335 @retval EFI_NOT_FOUND Target for the specified routing data 336 was not found. 337 **/ 338 EFI_STATUS 339 EFIAPI 340 BootMaintRouteConfig ( 341 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This, 342 IN CONST EFI_STRING Configuration, 343 OUT EFI_STRING *Progress 344 ) 345 { 346 EFI_STATUS Status; 347 UINTN BufferSize; 348 EFI_HII_CONFIG_ROUTING_PROTOCOL *ConfigRouting; 349 BMM_FAKE_NV_DATA *NewBmmData; 350 BMM_FAKE_NV_DATA *OldBmmData; 351 BM_CONSOLE_CONTEXT *NewConsoleContext; 352 BM_TERMINAL_CONTEXT *NewTerminalContext; 353 BM_MENU_ENTRY *NewMenuEntry; 354 BM_LOAD_CONTEXT *NewLoadContext; 355 UINT16 Index; 356 BOOLEAN TerminalAttChange; 357 BMM_CALLBACK_DATA *Private; 358 359 if (Progress == NULL) { 360 return EFI_INVALID_PARAMETER; 361 } 362 *Progress = Configuration; 363 364 if (Configuration == NULL) { 365 return EFI_INVALID_PARAMETER; 366 } 367 368 // 369 // Check routing data in <ConfigHdr>. 370 // Note: there is no name for Name/Value storage, only GUID will be checked 371 // 372 if (!HiiIsConfigHdrMatch (Configuration, &gBootMaintFormSetGuid, mBootMaintStorageName)) { 373 return EFI_NOT_FOUND; 374 } 375 376 Status = gBS->LocateProtocol ( 377 &gEfiHiiConfigRoutingProtocolGuid, 378 NULL, 379 (VOID**) &ConfigRouting 380 ); 381 if (EFI_ERROR (Status)) { 382 return Status; 383 } 384 385 Private = BMM_CALLBACK_DATA_FROM_THIS (This); 386 // 387 // Get Buffer Storage data from EFI variable 388 // 389 BufferSize = sizeof (BMM_FAKE_NV_DATA); 390 OldBmmData = &Private->BmmOldFakeNVData; 391 NewBmmData = &Private->BmmFakeNvData; 392 // 393 // Convert <ConfigResp> to buffer data by helper function ConfigToBlock() 394 // 395 Status = ConfigRouting->ConfigToBlock ( 396 ConfigRouting, 397 Configuration, 398 (UINT8 *) NewBmmData, 399 &BufferSize, 400 Progress 401 ); 402 ASSERT_EFI_ERROR (Status); 403 // 404 // Compare new and old BMM configuration data and only do action for modified item to 405 // avoid setting unnecessary non-volatile variable 406 // 407 408 // 409 // Check data which located in BMM main page and save the settings if need 410 // 411 if (CompareMem (NewBmmData->LegacyFD, OldBmmData->LegacyFD, sizeof (NewBmmData->LegacyFD)) != 0) { 412 Var_UpdateBBSOption (Private, FORM_SET_FD_ORDER_ID); 413 } 414 415 if (CompareMem (NewBmmData->LegacyHD, OldBmmData->LegacyHD, sizeof (NewBmmData->LegacyHD)) != 0) { 416 Var_UpdateBBSOption (Private, FORM_SET_HD_ORDER_ID); 417 } 418 419 if (CompareMem (NewBmmData->LegacyCD, OldBmmData->LegacyCD, sizeof (NewBmmData->LegacyCD)) != 0) { 420 Var_UpdateBBSOption (Private, FORM_SET_CD_ORDER_ID); 421 } 422 423 if (CompareMem (NewBmmData->LegacyNET, OldBmmData->LegacyNET, sizeof (NewBmmData->LegacyNET)) != 0) { 424 Var_UpdateBBSOption (Private, FORM_SET_NET_ORDER_ID); 425 } 426 427 if (CompareMem (NewBmmData->LegacyBEV, OldBmmData->LegacyBEV, sizeof (NewBmmData->LegacyBEV)) != 0) { 428 Var_UpdateBBSOption (Private, FORM_SET_BEV_ORDER_ID); 429 } 430 431 // 432 // Change for "delete boot option" page need update NewBmmData->BootOptionOrder, so process 433 // NewBmmData->BootOptionOrder before NewBmmData->BootOptionDel 434 // 435 if (CompareMem (NewBmmData->BootOptionOrder, OldBmmData->BootOptionOrder, sizeof (NewBmmData->BootOptionOrder)) != 0) { 436 Status = Var_UpdateBootOrder (Private); 437 } 438 439 // 440 // Change for "delete driver option" page need update NewBmmData->DriverOptionOrder, so process 441 // NewBmmData->DriverOptionOrder before NewBmmData->DriverOptionDel 442 // 443 if (CompareMem (NewBmmData->DriverOptionOrder, OldBmmData->DriverOptionOrder, sizeof (NewBmmData->DriverOptionOrder)) != 0) { 444 Status = Var_UpdateDriverOrder (Private); 445 } 446 447 // 448 // Check data which located in Boot Options Menu and save the settings if need 449 // 450 if (CompareMem (NewBmmData->BootOptionDel, OldBmmData->BootOptionDel, sizeof (NewBmmData->BootOptionDel)) != 0) { 451 for (Index = 0; 452 ((Index < BootOptionMenu.MenuNumber) && (Index < (sizeof (NewBmmData->BootOptionDel) / sizeof (NewBmmData->BootOptionDel[0])))); 453 Index ++) { 454 NewMenuEntry = BOpt_GetMenuEntry (&BootOptionMenu, Index); 455 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext; 456 NewLoadContext->Deleted = NewBmmData->BootOptionDel[Index]; 457 NewBmmData->BootOptionDel[Index] = FALSE; 458 NewBmmData->BootOptionDelMark[Index] = FALSE; 459 } 460 461 Var_DelBootOption (); 462 } 463 464 // 465 // Check data which located in Driver Options Menu and save the settings if need 466 // 467 if (CompareMem (NewBmmData->DriverOptionDel, OldBmmData->DriverOptionDel, sizeof (NewBmmData->DriverOptionDel)) != 0) { 468 for (Index = 0; 469 ((Index < DriverOptionMenu.MenuNumber) && (Index < (sizeof (NewBmmData->DriverOptionDel) / sizeof (NewBmmData->DriverOptionDel[0])))); 470 Index++) { 471 NewMenuEntry = BOpt_GetMenuEntry (&DriverOptionMenu, Index); 472 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext; 473 NewLoadContext->Deleted = NewBmmData->DriverOptionDel[Index]; 474 NewBmmData->DriverOptionDel[Index] = FALSE; 475 NewBmmData->DriverOptionDelMark[Index] = FALSE; 476 } 477 Var_DelDriverOption (); 478 } 479 480 if (CompareMem (&NewBmmData->BootTimeOut, &OldBmmData->BootTimeOut, sizeof (NewBmmData->BootTimeOut)) != 0) { 481 Status = gRT->SetVariable ( 482 L"Timeout", 483 &gEfiGlobalVariableGuid, 484 EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE, 485 sizeof (UINT16), 486 &(NewBmmData->BootTimeOut) 487 ); 488 ASSERT_EFI_ERROR(Status); 489 490 // 491 // Bugbug: code not exit in UiApp but in IntelFrameworkModulePkg, need do more check. 492 // 493 Private->BmmOldFakeNVData.BootTimeOut = NewBmmData->BootTimeOut; 494 } 495 496 if (CompareMem (&NewBmmData->BootNext, &OldBmmData->BootNext, sizeof (NewBmmData->BootNext)) != 0) { 497 Status = Var_UpdateBootNext (Private); 498 } 499 500 if (CompareMem (&NewBmmData->ConsoleOutMode, &OldBmmData->ConsoleOutMode, sizeof (NewBmmData->ConsoleOutMode)) != 0) { 501 Var_UpdateConMode (Private); 502 } 503 504 TerminalAttChange = FALSE; 505 for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) { 506 507 // 508 // only need update modified items 509 // 510 if (CompareMem (&NewBmmData->COMBaudRate[Index], &OldBmmData->COMBaudRate[Index], sizeof (NewBmmData->COMBaudRate[Index])) == 0 && 511 CompareMem (&NewBmmData->COMDataRate[Index], &OldBmmData->COMDataRate[Index], sizeof (NewBmmData->COMDataRate[Index])) == 0 && 512 CompareMem (&NewBmmData->COMStopBits[Index], &OldBmmData->COMStopBits[Index], sizeof (NewBmmData->COMStopBits[Index])) == 0 && 513 CompareMem (&NewBmmData->COMParity[Index], &OldBmmData->COMParity[Index], sizeof (NewBmmData->COMParity[Index])) == 0 && 514 CompareMem (&NewBmmData->COMTerminalType[Index], &OldBmmData->COMTerminalType[Index], sizeof (NewBmmData->COMTerminalType[Index])) == 0 && 515 CompareMem (&NewBmmData->COMFlowControl[Index], &OldBmmData->COMFlowControl[Index], sizeof (NewBmmData->COMFlowControl[Index])) == 0) { 516 continue; 517 } 518 519 NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Index); 520 ASSERT (NewMenuEntry != NULL); 521 NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext; 522 NewTerminalContext->BaudRateIndex = NewBmmData->COMBaudRate[Index]; 523 ASSERT (NewBmmData->COMBaudRate[Index] < (ARRAY_SIZE (BaudRateList))); 524 NewTerminalContext->BaudRate = BaudRateList[NewBmmData->COMBaudRate[Index]].Value; 525 NewTerminalContext->DataBitsIndex = NewBmmData->COMDataRate[Index]; 526 ASSERT (NewBmmData->COMDataRate[Index] < (ARRAY_SIZE (DataBitsList))); 527 NewTerminalContext->DataBits = (UINT8) DataBitsList[NewBmmData->COMDataRate[Index]].Value; 528 NewTerminalContext->StopBitsIndex = NewBmmData->COMStopBits[Index]; 529 ASSERT (NewBmmData->COMStopBits[Index] < (ARRAY_SIZE (StopBitsList))); 530 NewTerminalContext->StopBits = (UINT8) StopBitsList[NewBmmData->COMStopBits[Index]].Value; 531 NewTerminalContext->ParityIndex = NewBmmData->COMParity[Index]; 532 ASSERT (NewBmmData->COMParity[Index] < (ARRAY_SIZE (ParityList))); 533 NewTerminalContext->Parity = (UINT8) ParityList[NewBmmData->COMParity[Index]].Value; 534 NewTerminalContext->TerminalType = NewBmmData->COMTerminalType[Index]; 535 NewTerminalContext->FlowControl = NewBmmData->COMFlowControl[Index]; 536 ChangeTerminalDevicePath ( 537 &(NewTerminalContext->DevicePath), 538 FALSE 539 ); 540 TerminalAttChange = TRUE; 541 } 542 if (TerminalAttChange) { 543 Var_UpdateConsoleInpOption (); 544 Var_UpdateConsoleOutOption (); 545 Var_UpdateErrorOutOption (); 546 } 547 548 // 549 // Check data which located in Console Options Menu and save the settings if need 550 // 551 if (CompareMem (NewBmmData->ConsoleInCheck, OldBmmData->ConsoleInCheck, sizeof (NewBmmData->ConsoleInCheck)) != 0) { 552 for (Index = 0; Index < ConsoleInpMenu.MenuNumber; Index++) { 553 NewMenuEntry = BOpt_GetMenuEntry (&ConsoleInpMenu, Index); 554 NewConsoleContext = (BM_CONSOLE_CONTEXT *) NewMenuEntry->VariableContext; 555 ASSERT (Index < MAX_MENU_NUMBER); 556 NewConsoleContext->IsActive = NewBmmData->ConsoleInCheck[Index]; 557 } 558 559 Var_UpdateConsoleInpOption (); 560 } 561 562 if (CompareMem (NewBmmData->ConsoleOutCheck, OldBmmData->ConsoleOutCheck, sizeof (NewBmmData->ConsoleOutCheck)) != 0) { 563 for (Index = 0; Index < ConsoleOutMenu.MenuNumber; Index++) { 564 NewMenuEntry = BOpt_GetMenuEntry (&ConsoleOutMenu, Index); 565 NewConsoleContext = (BM_CONSOLE_CONTEXT *) NewMenuEntry->VariableContext; 566 ASSERT (Index < MAX_MENU_NUMBER); 567 NewConsoleContext->IsActive = NewBmmData->ConsoleOutCheck[Index]; 568 } 569 570 Var_UpdateConsoleOutOption (); 571 } 572 573 if (CompareMem (NewBmmData->ConsoleErrCheck, OldBmmData->ConsoleErrCheck, sizeof (NewBmmData->ConsoleErrCheck)) != 0) { 574 for (Index = 0; Index < ConsoleErrMenu.MenuNumber; Index++) { 575 NewMenuEntry = BOpt_GetMenuEntry (&ConsoleErrMenu, Index); 576 NewConsoleContext = (BM_CONSOLE_CONTEXT *) NewMenuEntry->VariableContext; 577 ASSERT (Index < MAX_MENU_NUMBER); 578 NewConsoleContext->IsActive = NewBmmData->ConsoleErrCheck[Index]; 579 } 580 581 Var_UpdateErrorOutOption (); 582 } 583 584 // 585 // After user do the save action, need to update OldBmmData. 586 // 587 CopyMem (OldBmmData, NewBmmData, sizeof (BMM_FAKE_NV_DATA)); 588 589 return EFI_SUCCESS; 590 } 591 592 /** 593 Create GoTo OP code into FORM_BOOT_LEGACY_DEVICE label for legacy boot option. 594 595 **/ 596 EFI_STATUS 597 InitializeLegacyBootOption ( 598 VOID 599 ) 600 { 601 RefreshUpdateData (); 602 mStartLabel->Number = FORM_BOOT_LEGACY_DEVICE_ID; 603 604 // 605 // If LegacyBios Protocol is installed, add 3 tags about legacy boot option 606 // in BootOption form: legacy FD/HD/CD/NET/BEV 607 // 608 HiiCreateGotoOpCode ( 609 mStartOpCodeHandle, 610 FORM_SET_FD_ORDER_ID, 611 STRING_TOKEN (STR_FORM_SET_FD_ORDER_TITLE), 612 STRING_TOKEN (STR_FORM_SET_FD_ORDER_TITLE), 613 EFI_IFR_FLAG_CALLBACK, 614 FORM_SET_FD_ORDER_ID 615 ); 616 617 HiiCreateGotoOpCode ( 618 mStartOpCodeHandle, 619 FORM_SET_HD_ORDER_ID, 620 STRING_TOKEN (STR_FORM_SET_HD_ORDER_TITLE), 621 STRING_TOKEN (STR_FORM_SET_HD_ORDER_TITLE), 622 EFI_IFR_FLAG_CALLBACK, 623 FORM_SET_HD_ORDER_ID 624 ); 625 626 HiiCreateGotoOpCode ( 627 mStartOpCodeHandle, 628 FORM_SET_CD_ORDER_ID, 629 STRING_TOKEN (STR_FORM_SET_CD_ORDER_TITLE), 630 STRING_TOKEN (STR_FORM_SET_CD_ORDER_TITLE), 631 EFI_IFR_FLAG_CALLBACK, 632 FORM_SET_CD_ORDER_ID 633 ); 634 635 HiiCreateGotoOpCode ( 636 mStartOpCodeHandle, 637 FORM_SET_NET_ORDER_ID, 638 STRING_TOKEN (STR_FORM_SET_NET_ORDER_TITLE), 639 STRING_TOKEN (STR_FORM_SET_NET_ORDER_TITLE), 640 EFI_IFR_FLAG_CALLBACK, 641 FORM_SET_NET_ORDER_ID 642 ); 643 644 HiiCreateGotoOpCode ( 645 mStartOpCodeHandle, 646 FORM_SET_BEV_ORDER_ID, 647 STRING_TOKEN (STR_FORM_SET_BEV_ORDER_TITLE), 648 STRING_TOKEN (STR_FORM_SET_BEV_ORDER_TITLE), 649 EFI_IFR_FLAG_CALLBACK, 650 FORM_SET_BEV_ORDER_ID 651 ); 652 653 HiiUpdateForm ( 654 mBmmCallbackInfo->BmmHiiHandle, 655 &gBootMaintFormSetGuid, 656 FORM_BOOT_SETUP_ID, 657 mStartOpCodeHandle, // Label FORM_BOOT_LEGACY_DEVICE_ID 658 mEndOpCodeHandle // LABEL_END 659 ); 660 661 return EFI_SUCCESS; 662 } 663 664 /** 665 This function processes the results of changes in configuration. 666 667 668 @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL. 669 @param Action Specifies the type of action taken by the browser. 670 @param QuestionId A unique value which is sent to the original exporting driver 671 so that it can identify the type of data to expect. 672 @param Type The type of value for the question. 673 @param Value A pointer to the data being sent to the original exporting driver. 674 @param ActionRequest On return, points to the action requested by the callback function. 675 676 @retval EFI_SUCCESS The callback successfully handled the action. 677 @retval EFI_OUT_OF_RESOURCES Not enough storage is available to hold the variable and its data. 678 @retval EFI_DEVICE_ERROR The variable could not be saved. 679 @retval EFI_UNSUPPORTED The specified Action is not supported by the callback. 680 @retval EFI_INVALID_PARAMETER The parameter of Value or ActionRequest is invalid. 681 **/ 682 EFI_STATUS 683 EFIAPI 684 BootMaintCallback ( 685 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This, 686 IN EFI_BROWSER_ACTION Action, 687 IN EFI_QUESTION_ID QuestionId, 688 IN UINT8 Type, 689 IN EFI_IFR_TYPE_VALUE *Value, 690 OUT EFI_BROWSER_ACTION_REQUEST *ActionRequest 691 ) 692 { 693 BMM_CALLBACK_DATA *Private; 694 BM_MENU_ENTRY *NewMenuEntry; 695 BMM_FAKE_NV_DATA *CurrentFakeNVMap; 696 EFI_STATUS Status; 697 UINTN OldValue; 698 UINTN NewValue; 699 UINTN Number; 700 UINTN Pos; 701 UINTN Bit; 702 UINT16 NewValuePos; 703 UINT16 Index3; 704 UINT16 Index2; 705 UINT16 Index; 706 UINT8 *OldLegacyDev; 707 UINT8 *NewLegacyDev; 708 UINT8 *DisMap; 709 EFI_LEGACY_BIOS_PROTOCOL *LegacyBios; 710 711 Private = BMM_CALLBACK_DATA_FROM_THIS (This); 712 if (Action == EFI_BROWSER_ACTION_FORM_OPEN && QuestionId == FORM_BOOT_SETUP_ID) { 713 // 714 // Initilize Form for legacy boot option. 715 // 716 Status = EfiLibLocateProtocol (&gEfiLegacyBiosProtocolGuid, (VOID **) &LegacyBios); 717 if (!EFI_ERROR (Status)) { 718 InitializeLegacyBootOption (); 719 } 720 721 return EFI_SUCCESS; 722 } 723 724 if (Action != EFI_BROWSER_ACTION_CHANGING && Action != EFI_BROWSER_ACTION_CHANGED) { 725 // 726 // All other action return unsupported. 727 // 728 return EFI_UNSUPPORTED; 729 } 730 731 Status = EFI_SUCCESS; 732 OldValue = 0; 733 NewValue = 0; 734 Number = 0; 735 OldLegacyDev = NULL; 736 NewLegacyDev = NULL; 737 NewValuePos = 0; 738 DisMap = NULL; 739 740 Private = BMM_CALLBACK_DATA_FROM_THIS (This); 741 // 742 // Retrieve uncommitted data from Form Browser 743 // 744 CurrentFakeNVMap = &Private->BmmFakeNvData; 745 HiiGetBrowserData (&gBootMaintFormSetGuid, mBootMaintStorageName, sizeof (BMM_FAKE_NV_DATA), (UINT8 *) CurrentFakeNVMap); 746 if (Action == EFI_BROWSER_ACTION_CHANGING) { 747 if (Value == NULL) { 748 return EFI_INVALID_PARAMETER; 749 } 750 751 UpdatePageId (Private, QuestionId); 752 753 if (QuestionId < FILE_OPTION_OFFSET) { 754 if (QuestionId < CONFIG_OPTION_OFFSET) { 755 switch (QuestionId) { 756 case KEY_VALUE_BOOT_FROM_FILE: 757 Private->FeCurrentState = FileExplorerStateBootFromFile; 758 break; 759 760 case FORM_BOOT_ADD_ID: 761 Private->FeCurrentState = FileExplorerStateAddBootOption; 762 break; 763 764 case FORM_DRV_ADD_FILE_ID: 765 Private->FeCurrentState = FileExplorerStateAddDriverOptionState; 766 break; 767 768 case FORM_DRV_ADD_HANDLE_ID: 769 CleanUpPage (FORM_DRV_ADD_HANDLE_ID, Private); 770 UpdateDrvAddHandlePage (Private); 771 break; 772 773 case FORM_BOOT_DEL_ID: 774 CleanUpPage (FORM_BOOT_DEL_ID, Private); 775 UpdateBootDelPage (Private); 776 break; 777 778 case FORM_BOOT_CHG_ID: 779 case FORM_DRV_CHG_ID: 780 UpdatePageBody (QuestionId, Private); 781 break; 782 783 case FORM_DRV_DEL_ID: 784 CleanUpPage (FORM_DRV_DEL_ID, Private); 785 UpdateDrvDelPage (Private); 786 break; 787 788 case FORM_BOOT_NEXT_ID: 789 CleanUpPage (FORM_BOOT_NEXT_ID, Private); 790 UpdateBootNextPage (Private); 791 break; 792 793 case FORM_TIME_OUT_ID: 794 CleanUpPage (FORM_TIME_OUT_ID, Private); 795 UpdateTimeOutPage (Private); 796 break; 797 798 case FORM_CON_IN_ID: 799 case FORM_CON_OUT_ID: 800 case FORM_CON_ERR_ID: 801 UpdatePageBody (QuestionId, Private); 802 break; 803 804 case FORM_CON_MODE_ID: 805 CleanUpPage (FORM_CON_MODE_ID, Private); 806 UpdateConModePage (Private); 807 break; 808 809 case FORM_CON_COM_ID: 810 CleanUpPage (FORM_CON_COM_ID, Private); 811 UpdateConCOMPage (Private); 812 break; 813 814 case FORM_SET_FD_ORDER_ID: 815 case FORM_SET_HD_ORDER_ID: 816 case FORM_SET_CD_ORDER_ID: 817 case FORM_SET_NET_ORDER_ID: 818 case FORM_SET_BEV_ORDER_ID: 819 CleanUpPage (QuestionId, Private); 820 UpdateSetLegacyDeviceOrderPage (QuestionId, Private); 821 break; 822 823 default: 824 break; 825 } 826 } else if ((QuestionId >= TERMINAL_OPTION_OFFSET) && (QuestionId < CONSOLE_OPTION_OFFSET)) { 827 Index2 = (UINT16) (QuestionId - TERMINAL_OPTION_OFFSET); 828 Private->CurrentTerminal = Index2; 829 830 CleanUpPage (FORM_CON_COM_SETUP_ID, Private); 831 UpdateTerminalPage (Private); 832 833 } else if (QuestionId >= HANDLE_OPTION_OFFSET) { 834 Index2 = (UINT16) (QuestionId - HANDLE_OPTION_OFFSET); 835 836 NewMenuEntry = BOpt_GetMenuEntry (&DriverMenu, Index2); 837 ASSERT (NewMenuEntry != NULL); 838 Private->HandleContext = (BM_HANDLE_CONTEXT *) NewMenuEntry->VariableContext; 839 840 CleanUpPage (FORM_DRV_ADD_HANDLE_DESC_ID, Private); 841 842 Private->MenuEntry = NewMenuEntry; 843 Private->LoadContext->FilePathList = Private->HandleContext->DevicePath; 844 845 UpdateDriverAddHandleDescPage (Private); 846 } 847 } 848 } else if (Action == EFI_BROWSER_ACTION_CHANGED) { 849 if ((Value == NULL) || (ActionRequest == NULL)) { 850 return EFI_INVALID_PARAMETER; 851 } 852 if ((QuestionId >= BOOT_OPTION_DEL_QUESTION_ID) && (QuestionId < BOOT_OPTION_DEL_QUESTION_ID + MAX_MENU_NUMBER)) { 853 if (Value->b){ 854 // 855 // Means user try to delete this boot option but not press F10 or "Commit Changes and Exit" menu. 856 // 857 CurrentFakeNVMap->BootOptionDelMark[QuestionId - BOOT_OPTION_DEL_QUESTION_ID] = TRUE; 858 } else { 859 // 860 // Means user remove the old check status. 861 // 862 CurrentFakeNVMap->BootOptionDelMark[QuestionId - BOOT_OPTION_DEL_QUESTION_ID] = FALSE; 863 } 864 } else if ((QuestionId >= DRIVER_OPTION_DEL_QUESTION_ID) && (QuestionId < DRIVER_OPTION_DEL_QUESTION_ID + MAX_MENU_NUMBER)) { 865 if (Value->b){ 866 CurrentFakeNVMap->DriverOptionDelMark[QuestionId - DRIVER_OPTION_DEL_QUESTION_ID] = TRUE; 867 } else { 868 CurrentFakeNVMap->DriverOptionDelMark[QuestionId - DRIVER_OPTION_DEL_QUESTION_ID] = FALSE; 869 } 870 } else if ((QuestionId >= LEGACY_FD_QUESTION_ID) && (QuestionId < LEGACY_BEV_QUESTION_ID + MAX_MENU_NUMBER)) { 871 // 872 // Update Select FD/HD/CD/NET/BEV Order Form 873 // 874 875 DisMap = Private->BmmOldFakeNVData.DisableMap; 876 877 if (QuestionId >= LEGACY_FD_QUESTION_ID && QuestionId < LEGACY_FD_QUESTION_ID + MAX_MENU_NUMBER) { 878 Number = (UINT16) LegacyFDMenu.MenuNumber; 879 OldLegacyDev = Private->BmmOldFakeNVData.LegacyFD; 880 NewLegacyDev = CurrentFakeNVMap->LegacyFD; 881 } else if (QuestionId >= LEGACY_HD_QUESTION_ID && QuestionId < LEGACY_HD_QUESTION_ID + MAX_MENU_NUMBER) { 882 Number = (UINT16) LegacyHDMenu.MenuNumber; 883 OldLegacyDev = Private->BmmOldFakeNVData.LegacyHD; 884 NewLegacyDev = CurrentFakeNVMap->LegacyHD; 885 } else if (QuestionId >= LEGACY_CD_QUESTION_ID && QuestionId < LEGACY_CD_QUESTION_ID + MAX_MENU_NUMBER) { 886 Number = (UINT16) LegacyCDMenu.MenuNumber; 887 OldLegacyDev = Private->BmmOldFakeNVData.LegacyCD; 888 NewLegacyDev = CurrentFakeNVMap->LegacyCD; 889 } else if (QuestionId >= LEGACY_NET_QUESTION_ID && QuestionId < LEGACY_NET_QUESTION_ID + MAX_MENU_NUMBER) { 890 Number = (UINT16) LegacyNETMenu.MenuNumber; 891 OldLegacyDev = Private->BmmOldFakeNVData.LegacyNET; 892 NewLegacyDev = CurrentFakeNVMap->LegacyNET; 893 } else if (QuestionId >= LEGACY_BEV_QUESTION_ID && QuestionId < LEGACY_BEV_QUESTION_ID + MAX_MENU_NUMBER) { 894 Number = (UINT16) LegacyBEVMenu.MenuNumber; 895 OldLegacyDev = Private->BmmOldFakeNVData.LegacyBEV; 896 NewLegacyDev = CurrentFakeNVMap->LegacyBEV; 897 } 898 // 899 // First, find the different position 900 // if there is change, it should be only one 901 // 902 for (Index = 0; Index < Number; Index++) { 903 if (OldLegacyDev[Index] != NewLegacyDev[Index]) { 904 OldValue = OldLegacyDev[Index]; 905 NewValue = NewLegacyDev[Index]; 906 break; 907 } 908 } 909 910 if (Index != Number) { 911 // 912 // there is change, now process 913 // 914 if (0xFF == NewValue) { 915 // 916 // This item will be disable 917 // Just move the items behind this forward to overlap it 918 // 919 Pos = OldValue / 8; 920 Bit = 7 - (OldValue % 8); 921 DisMap[Pos] = (UINT8) (DisMap[Pos] | (UINT8) (1 << Bit)); 922 for (Index2 = Index; Index2 < Number - 1; Index2++) { 923 NewLegacyDev[Index2] = NewLegacyDev[Index2 + 1]; 924 } 925 926 NewLegacyDev[Index2] = 0xFF; 927 } else { 928 for (Index2 = 0; Index2 < Number; Index2++) { 929 if (Index2 == Index) { 930 continue; 931 } 932 933 if (OldLegacyDev[Index2] == NewValue) { 934 // 935 // If NewValue is in OldLegacyDev array 936 // remember its old position 937 // 938 NewValuePos = Index2; 939 break; 940 } 941 } 942 943 if (Index2 != Number) { 944 // 945 // We will change current item to an existing item 946 // (It's hard to describe here, please read code, it's like a cycle-moving) 947 // 948 for (Index2 = NewValuePos; Index2 != Index;) { 949 if (NewValuePos < Index) { 950 NewLegacyDev[Index2] = OldLegacyDev[Index2 + 1]; 951 Index2++; 952 } else { 953 NewLegacyDev[Index2] = OldLegacyDev[Index2 - 1]; 954 Index2--; 955 } 956 } 957 } else { 958 // 959 // If NewValue is not in OldlegacyDev array, we are changing to a disabled item 960 // so we should modify DisMap to reflect the change 961 // 962 Pos = NewValue / 8; 963 Bit = 7 - (NewValue % 8); 964 DisMap[Pos] = (UINT8) (DisMap[Pos] & (~ (UINT8) (1 << Bit))); 965 if (0xFF != OldValue) { 966 // 967 // Because NewValue is a item that was disabled before 968 // so after changing the OldValue should be disabled 969 // actually we are doing a swap of enable-disable states of two items 970 // 971 Pos = OldValue / 8; 972 Bit = 7 - (OldValue % 8); 973 DisMap[Pos] = (UINT8) (DisMap[Pos] | (UINT8) (1 << Bit)); 974 } 975 } 976 } 977 // 978 // To prevent DISABLE appears in the middle of the list 979 // we should perform a re-ordering 980 // 981 Index3 = Index; 982 Index = 0; 983 while (Index < Number) { 984 if (0xFF != NewLegacyDev[Index]) { 985 Index++; 986 continue; 987 } 988 989 Index2 = Index; 990 Index2++; 991 while (Index2 < Number) { 992 if (0xFF != NewLegacyDev[Index2]) { 993 break; 994 } 995 996 Index2++; 997 } 998 999 if (Index2 < Number) { 1000 NewLegacyDev[Index] = NewLegacyDev[Index2]; 1001 NewLegacyDev[Index2] = 0xFF; 1002 } 1003 1004 Index++; 1005 } 1006 1007 // 1008 // Return correct question value. 1009 // 1010 Value->u8 = NewLegacyDev[Index3]; 1011 } 1012 } else { 1013 switch (QuestionId) { 1014 case KEY_VALUE_SAVE_AND_EXIT: 1015 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_SUBMIT_EXIT; 1016 break; 1017 1018 case KEY_VALUE_NO_SAVE_AND_EXIT: 1019 // 1020 // Restore local maintain data. 1021 // 1022 DiscardChangeHandler (Private, CurrentFakeNVMap); 1023 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_DISCARD_EXIT; 1024 break; 1025 1026 case FORM_RESET: 1027 gRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL); 1028 return EFI_UNSUPPORTED; 1029 1030 default: 1031 break; 1032 } 1033 } 1034 } 1035 1036 // 1037 // Pass changed uncommitted data back to Form Browser 1038 // 1039 HiiSetBrowserData (&gBootMaintFormSetGuid, mBootMaintStorageName, sizeof (BMM_FAKE_NV_DATA), (UINT8 *) CurrentFakeNVMap, NULL); 1040 return EFI_SUCCESS; 1041 } 1042 1043 /** 1044 Discard all changes done to the BMM pages such as Boot Order change, 1045 Driver order change. 1046 1047 @param Private The BMM context data. 1048 @param CurrentFakeNVMap The current Fack NV Map. 1049 1050 **/ 1051 VOID 1052 DiscardChangeHandler ( 1053 IN BMM_CALLBACK_DATA *Private, 1054 IN BMM_FAKE_NV_DATA *CurrentFakeNVMap 1055 ) 1056 { 1057 UINT16 Index; 1058 1059 switch (Private->BmmPreviousPageId) { 1060 case FORM_BOOT_CHG_ID: 1061 CopyMem (CurrentFakeNVMap->BootOptionOrder, Private->BmmOldFakeNVData.BootOptionOrder, sizeof (CurrentFakeNVMap->BootOptionOrder)); 1062 break; 1063 1064 case FORM_DRV_CHG_ID: 1065 CopyMem (CurrentFakeNVMap->DriverOptionOrder, Private->BmmOldFakeNVData.DriverOptionOrder, sizeof (CurrentFakeNVMap->DriverOptionOrder)); 1066 break; 1067 1068 case FORM_BOOT_DEL_ID: 1069 ASSERT (BootOptionMenu.MenuNumber <= (sizeof (CurrentFakeNVMap->BootOptionDel) / sizeof (CurrentFakeNVMap->BootOptionDel[0]))); 1070 for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) { 1071 CurrentFakeNVMap->BootOptionDel[Index] = FALSE; 1072 CurrentFakeNVMap->BootOptionDelMark[Index] = FALSE; 1073 } 1074 break; 1075 1076 case FORM_DRV_DEL_ID: 1077 ASSERT (DriverOptionMenu.MenuNumber <= (sizeof (CurrentFakeNVMap->DriverOptionDel) / sizeof (CurrentFakeNVMap->DriverOptionDel[0]))); 1078 for (Index = 0; Index < DriverOptionMenu.MenuNumber; Index++) { 1079 CurrentFakeNVMap->DriverOptionDel[Index] = FALSE; 1080 CurrentFakeNVMap->DriverOptionDelMark[Index] = FALSE; 1081 } 1082 break; 1083 1084 case FORM_BOOT_NEXT_ID: 1085 CurrentFakeNVMap->BootNext = Private->BmmOldFakeNVData.BootNext; 1086 break; 1087 1088 case FORM_TIME_OUT_ID: 1089 CurrentFakeNVMap->BootTimeOut = Private->BmmOldFakeNVData.BootTimeOut; 1090 break; 1091 1092 case FORM_DRV_ADD_HANDLE_DESC_ID: 1093 case FORM_DRV_ADD_FILE_ID: 1094 case FORM_DRV_ADD_HANDLE_ID: 1095 CurrentFakeNVMap->DriverAddHandleDesc[0] = 0x0000; 1096 CurrentFakeNVMap->DriverAddHandleOptionalData[0] = 0x0000; 1097 break; 1098 1099 default: 1100 break; 1101 } 1102 } 1103 1104 /** 1105 Initialize the Boot Maintenance Utitliy. 1106 1107 1108 @retval EFI_SUCCESS utility ended successfully 1109 @retval others contain some errors 1110 1111 **/ 1112 EFI_STATUS 1113 InitializeBM ( 1114 VOID 1115 ) 1116 { 1117 BMM_CALLBACK_DATA *BmmCallbackInfo; 1118 EFI_STATUS Status; 1119 EFI_HII_PACKAGE_LIST_HEADER *PackageListHeader; 1120 UINT32 Length; 1121 UINT8 *Data; 1122 1123 Status = EFI_SUCCESS; 1124 BmmCallbackInfo = mBmmCallbackInfo; 1125 1126 BmmCallbackInfo->BmmPreviousPageId = FORM_MAIN_ID; 1127 BmmCallbackInfo->BmmCurrentPageId = FORM_MAIN_ID; 1128 BmmCallbackInfo->FeCurrentState = FileExplorerStateInActive; 1129 BmmCallbackInfo->FeDisplayContext = FileExplorerDisplayUnknown; 1130 1131 // 1132 // Reinstall String packages to include more new strings. 1133 // 1134 1135 // 1136 // String package size 1137 // 1138 Length = ReadUnaligned32 ((UINT32 *) BdsDxeStrings) - sizeof (UINT32); 1139 1140 // 1141 // Add the length of the Package List Header and the terminating Package Header 1142 // 1143 Length += sizeof (EFI_HII_PACKAGE_LIST_HEADER) + sizeof (EFI_HII_PACKAGE_HEADER); 1144 1145 // 1146 // Allocate the storage for the entire Package List 1147 // 1148 PackageListHeader = AllocateZeroPool (Length); 1149 1150 // 1151 // If the Package List can not be allocated, then return a NULL HII Handle 1152 // 1153 if (PackageListHeader == NULL) { 1154 return EFI_OUT_OF_RESOURCES; 1155 } 1156 1157 // 1158 // Fill in the GUID and Length of the Package List Header 1159 // 1160 PackageListHeader->PackageLength = Length; 1161 1162 // 1163 // Copy String Data into Package list. 1164 // 1165 Data = (UINT8 *)(PackageListHeader + 1); 1166 Length = ReadUnaligned32 ((UINT32 *) BdsDxeStrings) - sizeof (UINT32); 1167 CopyMem (Data, (UINT8 *) BdsDxeStrings + sizeof (UINT32), Length); 1168 1169 // 1170 // Add End type HII package. 1171 // 1172 Data += Length; 1173 ((EFI_HII_PACKAGE_HEADER *) Data)->Type = EFI_HII_PACKAGE_END; 1174 ((EFI_HII_PACKAGE_HEADER *) Data)->Length = sizeof (EFI_HII_PACKAGE_HEADER); 1175 1176 // 1177 // Update String package for BM 1178 // 1179 CopyGuid (&PackageListHeader->PackageListGuid, &gBootMaintFormSetGuid); 1180 Status = gHiiDatabase->UpdatePackageList (gHiiDatabase, BmmCallbackInfo->BmmHiiHandle, PackageListHeader); 1181 1182 // 1183 // Update String package for FE. 1184 // 1185 CopyGuid (&PackageListHeader->PackageListGuid, &gFileExploreFormSetGuid); 1186 Status = gHiiDatabase->UpdatePackageList (gHiiDatabase, BmmCallbackInfo->FeHiiHandle, PackageListHeader); 1187 1188 FreePool (PackageListHeader); 1189 1190 // 1191 // Init OpCode Handle and Allocate space for creation of Buffer 1192 // 1193 mStartOpCodeHandle = HiiAllocateOpCodeHandle (); 1194 if (mStartOpCodeHandle == NULL) { 1195 Status = EFI_OUT_OF_RESOURCES; 1196 goto Exit; 1197 } 1198 1199 mEndOpCodeHandle = HiiAllocateOpCodeHandle (); 1200 if (mEndOpCodeHandle == NULL) { 1201 Status = EFI_OUT_OF_RESOURCES; 1202 goto Exit; 1203 } 1204 1205 // 1206 // Create Hii Extend Label OpCode as the start opcode 1207 // 1208 mStartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (mStartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL)); 1209 mStartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL; 1210 1211 // 1212 // Create Hii Extend Label OpCode as the end opcode 1213 // 1214 mEndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (mEndOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL)); 1215 mEndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL; 1216 mEndLabel->Number = LABEL_END; 1217 1218 InitializeStringDepository (); 1219 1220 InitAllMenu (BmmCallbackInfo); 1221 1222 CreateMenuStringToken (BmmCallbackInfo, BmmCallbackInfo->BmmHiiHandle, &ConsoleInpMenu); 1223 CreateMenuStringToken (BmmCallbackInfo, BmmCallbackInfo->BmmHiiHandle, &ConsoleOutMenu); 1224 CreateMenuStringToken (BmmCallbackInfo, BmmCallbackInfo->BmmHiiHandle, &ConsoleErrMenu); 1225 CreateMenuStringToken (BmmCallbackInfo, BmmCallbackInfo->BmmHiiHandle, &BootOptionMenu); 1226 CreateMenuStringToken (BmmCallbackInfo, BmmCallbackInfo->BmmHiiHandle, &DriverOptionMenu); 1227 CreateMenuStringToken (BmmCallbackInfo, BmmCallbackInfo->BmmHiiHandle, &TerminalMenu); 1228 CreateMenuStringToken (BmmCallbackInfo, BmmCallbackInfo->BmmHiiHandle, &DriverMenu); 1229 1230 InitializeBmmConfig (BmmCallbackInfo); 1231 1232 // 1233 // Dispatch BMM main formset and File Explorer formset. 1234 // 1235 FormSetDispatcher (BmmCallbackInfo); 1236 1237 // 1238 // Clean up. 1239 // 1240 CleanUpStringDepository (); 1241 1242 FreeAllMenu (); 1243 1244 Exit: 1245 if (mStartOpCodeHandle != NULL) { 1246 HiiFreeOpCodeHandle (mStartOpCodeHandle); 1247 } 1248 1249 if (mEndOpCodeHandle != NULL) { 1250 HiiFreeOpCodeHandle (mEndOpCodeHandle); 1251 } 1252 1253 return Status; 1254 } 1255 1256 1257 /** 1258 Initialized all Menu Option List. 1259 1260 @param CallbackData The BMM context data. 1261 1262 **/ 1263 VOID 1264 InitAllMenu ( 1265 IN BMM_CALLBACK_DATA *CallbackData 1266 ) 1267 { 1268 InitializeListHead (&BootOptionMenu.Head); 1269 InitializeListHead (&DriverOptionMenu.Head); 1270 BOpt_GetBootOptions (CallbackData); 1271 BOpt_GetDriverOptions (CallbackData); 1272 BOpt_GetLegacyOptions (); 1273 InitializeListHead (&FsOptionMenu.Head); 1274 BOpt_FindDrivers (); 1275 InitializeListHead (&DirectoryMenu.Head); 1276 InitializeListHead (&ConsoleInpMenu.Head); 1277 InitializeListHead (&ConsoleOutMenu.Head); 1278 InitializeListHead (&ConsoleErrMenu.Head); 1279 InitializeListHead (&TerminalMenu.Head); 1280 LocateSerialIo (); 1281 GetAllConsoles (); 1282 } 1283 1284 /** 1285 Free up all Menu Option list. 1286 1287 **/ 1288 VOID 1289 FreeAllMenu ( 1290 VOID 1291 ) 1292 { 1293 BOpt_FreeMenu (&DirectoryMenu); 1294 BOpt_FreeMenu (&FsOptionMenu); 1295 BOpt_FreeMenu (&BootOptionMenu); 1296 BOpt_FreeMenu (&DriverOptionMenu); 1297 BOpt_FreeMenu (&DriverMenu); 1298 BOpt_FreeLegacyOptions (); 1299 FreeAllConsoles (); 1300 } 1301 1302 /** 1303 Initialize all the string depositories. 1304 1305 **/ 1306 VOID 1307 InitializeStringDepository ( 1308 VOID 1309 ) 1310 { 1311 STRING_DEPOSITORY *StringDepository; 1312 StringDepository = AllocateZeroPool (sizeof (STRING_DEPOSITORY) * STRING_DEPOSITORY_NUMBER); 1313 FileOptionStrDepository = StringDepository++; 1314 ConsoleOptionStrDepository = StringDepository++; 1315 BootOptionStrDepository = StringDepository++; 1316 BootOptionHelpStrDepository = StringDepository++; 1317 DriverOptionStrDepository = StringDepository++; 1318 DriverOptionHelpStrDepository = StringDepository++; 1319 TerminalStrDepository = StringDepository; 1320 } 1321 1322 /** 1323 Fetch a usable string node from the string depository and return the string token. 1324 1325 @param CallbackData The BMM context data. 1326 @param StringDepository The string repository. 1327 1328 @retval EFI_STRING_ID String token. 1329 1330 **/ 1331 EFI_STRING_ID 1332 GetStringTokenFromDepository ( 1333 IN BMM_CALLBACK_DATA *CallbackData, 1334 IN STRING_DEPOSITORY *StringDepository 1335 ) 1336 { 1337 STRING_LIST_NODE *CurrentListNode; 1338 STRING_LIST_NODE *NextListNode; 1339 1340 CurrentListNode = StringDepository->CurrentNode; 1341 1342 if ((NULL != CurrentListNode) && (NULL != CurrentListNode->Next)) { 1343 // 1344 // Fetch one reclaimed node from the list. 1345 // 1346 NextListNode = StringDepository->CurrentNode->Next; 1347 } else { 1348 // 1349 // If there is no usable node in the list, update the list. 1350 // 1351 NextListNode = AllocateZeroPool (sizeof (STRING_LIST_NODE)); 1352 ASSERT (NextListNode != NULL); 1353 NextListNode->StringToken = HiiSetString (CallbackData->BmmHiiHandle, 0, L" ", NULL); 1354 ASSERT (NextListNode->StringToken != 0); 1355 1356 StringDepository->TotalNodeNumber++; 1357 1358 if (NULL == CurrentListNode) { 1359 StringDepository->ListHead = NextListNode; 1360 } else { 1361 CurrentListNode->Next = NextListNode; 1362 } 1363 } 1364 1365 StringDepository->CurrentNode = NextListNode; 1366 1367 return StringDepository->CurrentNode->StringToken; 1368 } 1369 1370 /** 1371 Reclaim string depositories by moving the current node pointer to list head.. 1372 1373 **/ 1374 VOID 1375 ReclaimStringDepository ( 1376 VOID 1377 ) 1378 { 1379 UINTN DepositoryIndex; 1380 STRING_DEPOSITORY *StringDepository; 1381 1382 StringDepository = FileOptionStrDepository; 1383 for (DepositoryIndex = 0; DepositoryIndex < STRING_DEPOSITORY_NUMBER; DepositoryIndex++) { 1384 StringDepository->CurrentNode = StringDepository->ListHead; 1385 StringDepository++; 1386 } 1387 } 1388 1389 /** 1390 Release resource for all the string depositories. 1391 1392 **/ 1393 VOID 1394 CleanUpStringDepository ( 1395 VOID 1396 ) 1397 { 1398 UINTN NodeIndex; 1399 UINTN DepositoryIndex; 1400 STRING_LIST_NODE *CurrentListNode; 1401 STRING_LIST_NODE *NextListNode; 1402 STRING_DEPOSITORY *StringDepository; 1403 1404 // 1405 // Release string list nodes. 1406 // 1407 StringDepository = FileOptionStrDepository; 1408 for (DepositoryIndex = 0; DepositoryIndex < STRING_DEPOSITORY_NUMBER; DepositoryIndex++) { 1409 CurrentListNode = StringDepository->ListHead; 1410 for (NodeIndex = 0; NodeIndex < StringDepository->TotalNodeNumber; NodeIndex++) { 1411 NextListNode = CurrentListNode->Next; 1412 FreePool (CurrentListNode); 1413 CurrentListNode = NextListNode; 1414 } 1415 1416 StringDepository++; 1417 } 1418 // 1419 // Release string depository. 1420 // 1421 FreePool (FileOptionStrDepository); 1422 } 1423 1424 /** 1425 Start boot maintenance manager 1426 1427 @retval EFI_SUCCESS If BMM is invoked successfully. 1428 @return Other value if BMM return unsuccessfully. 1429 1430 **/ 1431 EFI_STATUS 1432 BdsStartBootMaint ( 1433 VOID 1434 ) 1435 { 1436 EFI_STATUS Status; 1437 LIST_ENTRY BdsBootOptionList; 1438 1439 InitializeListHead (&BdsBootOptionList); 1440 1441 // 1442 // Connect all prior to entering the platform setup menu. 1443 // 1444 if (!gConnectAllHappened) { 1445 BdsLibConnectAllDriversToAllControllers (); 1446 gConnectAllHappened = TRUE; 1447 } 1448 // 1449 // Have chance to enumerate boot device 1450 // 1451 BdsLibEnumerateAllBootOption (&BdsBootOptionList); 1452 1453 // 1454 // Group the legacy boot options for the same device type 1455 // 1456 GroupMultipleLegacyBootOption4SameType (); 1457 1458 // 1459 // Init the BMM 1460 // 1461 Status = InitializeBM (); 1462 1463 return Status; 1464 } 1465 1466 /** 1467 Dispatch BMM formset and FileExplorer formset. 1468 1469 1470 @param CallbackData The BMM context data. 1471 1472 @retval EFI_SUCCESS If function complete successfully. 1473 @return Other value if the Setup Browser process BMM's pages and 1474 return unsuccessfully. 1475 1476 **/ 1477 EFI_STATUS 1478 FormSetDispatcher ( 1479 IN BMM_CALLBACK_DATA *CallbackData 1480 ) 1481 { 1482 EFI_STATUS Status; 1483 EFI_BROWSER_ACTION_REQUEST ActionRequest; 1484 1485 while (TRUE) { 1486 UpdatePageId (CallbackData, FORM_MAIN_ID); 1487 1488 ActionRequest = EFI_BROWSER_ACTION_REQUEST_NONE; 1489 Status = gFormBrowser2->SendForm ( 1490 gFormBrowser2, 1491 &CallbackData->BmmHiiHandle, 1492 1, 1493 &gBootMaintFormSetGuid, 1494 0, 1495 NULL, 1496 &ActionRequest 1497 ); 1498 if (ActionRequest == EFI_BROWSER_ACTION_REQUEST_RESET) { 1499 EnableResetRequired (); 1500 } 1501 1502 ReclaimStringDepository (); 1503 1504 // 1505 // When this Formset returns, check if we are going to explore files. 1506 // 1507 if (FileExplorerStateInActive != CallbackData->FeCurrentState) { 1508 UpdateFileExplorer (CallbackData, 0); 1509 1510 ActionRequest = EFI_BROWSER_ACTION_REQUEST_NONE; 1511 Status = gFormBrowser2->SendForm ( 1512 gFormBrowser2, 1513 &CallbackData->FeHiiHandle, 1514 1, 1515 &gFileExploreFormSetGuid, 1516 0, 1517 NULL, 1518 &ActionRequest 1519 ); 1520 if (ActionRequest == EFI_BROWSER_ACTION_REQUEST_RESET) { 1521 EnableResetRequired (); 1522 } 1523 1524 CallbackData->FeCurrentState = FileExplorerStateInActive; 1525 CallbackData->FeDisplayContext = FileExplorerDisplayUnknown; 1526 ReclaimStringDepository (); 1527 } else { 1528 break; 1529 } 1530 } 1531 1532 return Status; 1533 } 1534 1535 /** 1536 Intall BootMaint and FileExplorer HiiPackages. 1537 1538 **/ 1539 EFI_STATUS 1540 InitBMPackage ( 1541 VOID 1542 ) 1543 { 1544 BMM_CALLBACK_DATA *BmmCallbackInfo; 1545 EFI_STATUS Status; 1546 UINT8 *Ptr; 1547 1548 // 1549 // Create CallbackData structures for Driver Callback 1550 // 1551 BmmCallbackInfo = AllocateZeroPool (sizeof (BMM_CALLBACK_DATA)); 1552 if (BmmCallbackInfo == NULL) { 1553 return EFI_OUT_OF_RESOURCES; 1554 } 1555 1556 // 1557 // Create LoadOption in BmmCallbackInfo for Driver Callback 1558 // 1559 Ptr = AllocateZeroPool (sizeof (BM_LOAD_CONTEXT) + sizeof (BM_FILE_CONTEXT) + sizeof (BM_HANDLE_CONTEXT) + sizeof (BM_MENU_ENTRY)); 1560 if (Ptr == NULL) { 1561 FreePool (BmmCallbackInfo); 1562 BmmCallbackInfo = NULL; 1563 return EFI_OUT_OF_RESOURCES; 1564 } 1565 // 1566 // Initialize Bmm callback data. 1567 // 1568 BmmCallbackInfo->LoadContext = (BM_LOAD_CONTEXT *) Ptr; 1569 Ptr += sizeof (BM_LOAD_CONTEXT); 1570 1571 BmmCallbackInfo->FileContext = (BM_FILE_CONTEXT *) Ptr; 1572 Ptr += sizeof (BM_FILE_CONTEXT); 1573 1574 BmmCallbackInfo->HandleContext = (BM_HANDLE_CONTEXT *) Ptr; 1575 Ptr += sizeof (BM_HANDLE_CONTEXT); 1576 1577 BmmCallbackInfo->MenuEntry = (BM_MENU_ENTRY *) Ptr; 1578 1579 BmmCallbackInfo->Signature = BMM_CALLBACK_DATA_SIGNATURE; 1580 BmmCallbackInfo->BmmConfigAccess.ExtractConfig = BootMaintExtractConfig; 1581 BmmCallbackInfo->BmmConfigAccess.RouteConfig = BootMaintRouteConfig; 1582 BmmCallbackInfo->BmmConfigAccess.Callback = BootMaintCallback; 1583 BmmCallbackInfo->FeConfigAccess.ExtractConfig = FakeExtractConfig; 1584 BmmCallbackInfo->FeConfigAccess.RouteConfig = FileExplorerRouteConfig; 1585 BmmCallbackInfo->FeConfigAccess.Callback = FileExplorerCallback; 1586 1587 // 1588 // Install Device Path Protocol and Config Access protocol to driver handle 1589 // 1590 Status = gBS->InstallMultipleProtocolInterfaces ( 1591 &BmmCallbackInfo->BmmDriverHandle, 1592 &gEfiDevicePathProtocolGuid, 1593 &mBmmHiiVendorDevicePath, 1594 &gEfiHiiConfigAccessProtocolGuid, 1595 &BmmCallbackInfo->BmmConfigAccess, 1596 NULL 1597 ); 1598 ASSERT_EFI_ERROR (Status); 1599 1600 // 1601 // Install Device Path Protocol and Config Access protocol to driver handle 1602 // 1603 Status = gBS->InstallMultipleProtocolInterfaces ( 1604 &BmmCallbackInfo->FeDriverHandle, 1605 &gEfiDevicePathProtocolGuid, 1606 &mFeHiiVendorDevicePath, 1607 &gEfiHiiConfigAccessProtocolGuid, 1608 &BmmCallbackInfo->FeConfigAccess, 1609 NULL 1610 ); 1611 ASSERT_EFI_ERROR (Status); 1612 1613 // 1614 // Post our Boot Maint VFR binary to the HII database. 1615 // 1616 BmmCallbackInfo->BmmHiiHandle = HiiAddPackages ( 1617 &gBootMaintFormSetGuid, 1618 BmmCallbackInfo->BmmDriverHandle, 1619 BmBin, 1620 BdsDxeStrings, 1621 NULL 1622 ); 1623 ASSERT (BmmCallbackInfo->BmmHiiHandle != NULL); 1624 1625 // 1626 // Post our File Explorer VFR binary to the HII database. 1627 // 1628 BmmCallbackInfo->FeHiiHandle = HiiAddPackages ( 1629 &gFileExploreFormSetGuid, 1630 BmmCallbackInfo->FeDriverHandle, 1631 FEBin, 1632 BdsDxeStrings, 1633 NULL 1634 ); 1635 ASSERT (BmmCallbackInfo->FeHiiHandle != NULL); 1636 1637 mBmmCallbackInfo = BmmCallbackInfo; 1638 1639 return EFI_SUCCESS; 1640 } 1641 1642 /** 1643 Remvoe the intalled BootMaint and FileExplorer HiiPackages. 1644 1645 **/ 1646 VOID 1647 FreeBMPackage ( 1648 VOID 1649 ) 1650 { 1651 BMM_CALLBACK_DATA *BmmCallbackInfo; 1652 1653 BmmCallbackInfo = mBmmCallbackInfo; 1654 1655 // 1656 // Remove our IFR data from HII database 1657 // 1658 HiiRemovePackages (BmmCallbackInfo->BmmHiiHandle); 1659 HiiRemovePackages (BmmCallbackInfo->FeHiiHandle); 1660 1661 if (BmmCallbackInfo->FeDriverHandle != NULL) { 1662 gBS->UninstallMultipleProtocolInterfaces ( 1663 BmmCallbackInfo->FeDriverHandle, 1664 &gEfiDevicePathProtocolGuid, 1665 &mFeHiiVendorDevicePath, 1666 &gEfiHiiConfigAccessProtocolGuid, 1667 &BmmCallbackInfo->FeConfigAccess, 1668 NULL 1669 ); 1670 } 1671 1672 if (BmmCallbackInfo->BmmDriverHandle != NULL) { 1673 gBS->UninstallMultipleProtocolInterfaces ( 1674 BmmCallbackInfo->BmmDriverHandle, 1675 &gEfiDevicePathProtocolGuid, 1676 &mBmmHiiVendorDevicePath, 1677 &gEfiHiiConfigAccessProtocolGuid, 1678 &BmmCallbackInfo->BmmConfigAccess, 1679 NULL 1680 ); 1681 } 1682 1683 FreePool (BmmCallbackInfo->LoadContext); 1684 FreePool (BmmCallbackInfo); 1685 1686 mBmmCallbackInfo = NULL; 1687 1688 return; 1689 } 1690 1691
