2d52f9bac3929ba2b6c4ec4a9a31b8ab5a081d4c
[mirror_edk2.git] / MdeModulePkg / Library / BootMaintenanceManagerLib / BootMaintenance.c
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 "BootMaintenanceManager.h"
16
17 #define FRONT_PAGE_KEY_OFFSET 0x4000
18 //
19 // Boot video resolution and text mode.
20 //
21 UINT32 mBmmBootHorizontalResolution = 0;
22 UINT32 mBmmBootVerticalResolution = 0;
23 UINT32 mBmmBootTextModeColumn = 0;
24 UINT32 mBmmBootTextModeRow = 0;
25 //
26 // BIOS setup video resolution and text mode.
27 //
28 UINT32 mBmmSetupTextModeColumn = 0;
29 UINT32 mBmmSetupTextModeRow = 0;
30 UINT32 mBmmSetupHorizontalResolution = 0;
31 UINT32 mBmmSetupVerticalResolution = 0;
32
33 EFI_DEVICE_PATH_PROTOCOL EndDevicePath[] = {
34 {
35 END_DEVICE_PATH_TYPE,
36 END_ENTIRE_DEVICE_PATH_SUBTYPE,
37 {
38 END_DEVICE_PATH_LENGTH,
39 0
40 }
41 }
42 };
43
44 HII_VENDOR_DEVICE_PATH mBmmHiiVendorDevicePath = {
45 {
46 {
47 HARDWARE_DEVICE_PATH,
48 HW_VENDOR_DP,
49 {
50 (UINT8) (sizeof (VENDOR_DEVICE_PATH)),
51 (UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8)
52 }
53 },
54 //
55 // {165A028F-0BB2-4b5f-8747-77592E3F6499}
56 //
57 { 0x165a028f, 0xbb2, 0x4b5f, { 0x87, 0x47, 0x77, 0x59, 0x2e, 0x3f, 0x64, 0x99 } }
58 },
59 {
60 END_DEVICE_PATH_TYPE,
61 END_ENTIRE_DEVICE_PATH_SUBTYPE,
62 {
63 (UINT8) (END_DEVICE_PATH_LENGTH),
64 (UINT8) ((END_DEVICE_PATH_LENGTH) >> 8)
65 }
66 }
67 };
68
69 EFI_GUID mBootMaintGuid = BOOT_MAINT_FORMSET_GUID;
70
71 CHAR16 mBootMaintStorageName[] = L"BmmData";
72 BMM_CALLBACK_DATA gBootMaintenancePrivate = {
73 BMM_CALLBACK_DATA_SIGNATURE,
74 NULL,
75 NULL,
76 {
77 BootMaintExtractConfig,
78 BootMaintRouteConfig,
79 BootMaintCallback
80 }
81 };
82
83 BMM_CALLBACK_DATA *mBmmCallbackInfo = &gBootMaintenancePrivate;
84 BOOLEAN mAllMenuInit = FALSE;
85
86 /**
87 Init all memu.
88
89 @param CallbackData The BMM context data.
90
91 **/
92 VOID
93 InitAllMenu (
94 IN BMM_CALLBACK_DATA *CallbackData
95 );
96
97 /**
98 Free up all Menu Option list.
99
100 **/
101 VOID
102 FreeAllMenu (
103 VOID
104 );
105
106 /**
107 This function will change video resolution and text mode
108 according to defined setup mode or defined boot mode
109
110 @param IsSetupMode Indicate mode is changed to setup mode or boot mode.
111
112 @retval EFI_SUCCESS Mode is changed successfully.
113 @retval Others Mode failed to be changed.
114
115 **/
116 EFI_STATUS
117 EFIAPI
118 BmmBdsSetConsoleMode (
119 BOOLEAN IsSetupMode
120 )
121 {
122 EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
123 EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *SimpleTextOut;
124 UINTN SizeOfInfo;
125 EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *Info;
126 UINT32 MaxGopMode;
127 UINT32 MaxTextMode;
128 UINT32 ModeNumber;
129 UINT32 NewHorizontalResolution;
130 UINT32 NewVerticalResolution;
131 UINT32 NewColumns;
132 UINT32 NewRows;
133 UINTN HandleCount;
134 EFI_HANDLE *HandleBuffer;
135 EFI_STATUS Status;
136 UINTN Index;
137 UINTN CurrentColumn;
138 UINTN CurrentRow;
139
140 MaxGopMode = 0;
141 MaxTextMode = 0;
142
143 //
144 // Get current video resolution and text mode
145 //
146 Status = gBS->HandleProtocol (
147 gST->ConsoleOutHandle,
148 &gEfiGraphicsOutputProtocolGuid,
149 (VOID**)&GraphicsOutput
150 );
151 if (EFI_ERROR (Status)) {
152 GraphicsOutput = NULL;
153 }
154
155 Status = gBS->HandleProtocol (
156 gST->ConsoleOutHandle,
157 &gEfiSimpleTextOutProtocolGuid,
158 (VOID**)&SimpleTextOut
159 );
160 if (EFI_ERROR (Status)) {
161 SimpleTextOut = NULL;
162 }
163
164 if ((GraphicsOutput == NULL) || (SimpleTextOut == NULL)) {
165 return EFI_UNSUPPORTED;
166 }
167
168 if (IsSetupMode) {
169 //
170 // The requried resolution and text mode is setup mode.
171 //
172 NewHorizontalResolution = mBmmSetupHorizontalResolution;
173 NewVerticalResolution = mBmmSetupVerticalResolution;
174 NewColumns = mBmmSetupTextModeColumn;
175 NewRows = mBmmSetupTextModeRow;
176 } else {
177 //
178 // The required resolution and text mode is boot mode.
179 //
180 NewHorizontalResolution = mBmmBootHorizontalResolution;
181 NewVerticalResolution = mBmmBootVerticalResolution;
182 NewColumns = mBmmBootTextModeColumn;
183 NewRows = mBmmBootTextModeRow;
184 }
185
186 if (GraphicsOutput != NULL) {
187 MaxGopMode = GraphicsOutput->Mode->MaxMode;
188 }
189
190 if (SimpleTextOut != NULL) {
191 MaxTextMode = SimpleTextOut->Mode->MaxMode;
192 }
193
194 //
195 // 1. If current video resolution is same with required video resolution,
196 // video resolution need not be changed.
197 // 1.1. If current text mode is same with required text mode, text mode need not be changed.
198 // 1.2. If current text mode is different from required text mode, text mode need be changed.
199 // 2. If current video resolution is different from required video resolution, we need restart whole console drivers.
200 //
201 for (ModeNumber = 0; ModeNumber < MaxGopMode; ModeNumber++) {
202 Status = GraphicsOutput->QueryMode (
203 GraphicsOutput,
204 ModeNumber,
205 &SizeOfInfo,
206 &Info
207 );
208 if (!EFI_ERROR (Status)) {
209 if ((Info->HorizontalResolution == NewHorizontalResolution) &&
210 (Info->VerticalResolution == NewVerticalResolution)) {
211 if ((GraphicsOutput->Mode->Info->HorizontalResolution == NewHorizontalResolution) &&
212 (GraphicsOutput->Mode->Info->VerticalResolution == NewVerticalResolution)) {
213 //
214 // Current resolution is same with required resolution, check if text mode need be set
215 //
216 Status = SimpleTextOut->QueryMode (SimpleTextOut, SimpleTextOut->Mode->Mode, &CurrentColumn, &CurrentRow);
217 ASSERT_EFI_ERROR (Status);
218 if (CurrentColumn == NewColumns && CurrentRow == NewRows) {
219 //
220 // If current text mode is same with required text mode. Do nothing
221 //
222 FreePool (Info);
223 return EFI_SUCCESS;
224 } else {
225 //
226 // If current text mode is different from requried text mode. Set new video mode
227 //
228 for (Index = 0; Index < MaxTextMode; Index++) {
229 Status = SimpleTextOut->QueryMode (SimpleTextOut, Index, &CurrentColumn, &CurrentRow);
230 if (!EFI_ERROR(Status)) {
231 if ((CurrentColumn == NewColumns) && (CurrentRow == NewRows)) {
232 //
233 // Required text mode is supported, set it.
234 //
235 Status = SimpleTextOut->SetMode (SimpleTextOut, Index);
236 ASSERT_EFI_ERROR (Status);
237 //
238 // Update text mode PCD.
239 //
240 Status = PcdSet32S (PcdConOutColumn, mBmmSetupTextModeColumn);
241 ASSERT_EFI_ERROR (Status);
242 Status = PcdSet32S (PcdConOutRow, mBmmSetupTextModeRow);
243 ASSERT_EFI_ERROR (Status);
244 FreePool (Info);
245 return EFI_SUCCESS;
246 }
247 }
248 }
249 if (Index == MaxTextMode) {
250 //
251 // If requried text mode is not supported, return error.
252 //
253 FreePool (Info);
254 return EFI_UNSUPPORTED;
255 }
256 }
257 } else {
258 //
259 // If current video resolution is not same with the new one, set new video resolution.
260 // In this case, the driver which produces simple text out need be restarted.
261 //
262 Status = GraphicsOutput->SetMode (GraphicsOutput, ModeNumber);
263 if (!EFI_ERROR (Status)) {
264 FreePool (Info);
265 break;
266 }
267 }
268 }
269 FreePool (Info);
270 }
271 }
272
273 if (ModeNumber == MaxGopMode) {
274 //
275 // If the resolution is not supported, return error.
276 //
277 return EFI_UNSUPPORTED;
278 }
279
280 //
281 // Set PCD to Inform GraphicsConsole to change video resolution.
282 // Set PCD to Inform Consplitter to change text mode.
283 //
284 Status = PcdSet32S (PcdVideoHorizontalResolution, NewHorizontalResolution);
285 ASSERT_EFI_ERROR (Status);
286 Status = PcdSet32S (PcdVideoVerticalResolution, NewVerticalResolution);
287 ASSERT_EFI_ERROR (Status);
288 Status = PcdSet32S (PcdConOutColumn, NewColumns);
289 ASSERT_EFI_ERROR (Status);
290 Status = PcdSet32S (PcdConOutRow, NewRows);
291 ASSERT_EFI_ERROR (Status);
292
293 //
294 // Video mode is changed, so restart graphics console driver and higher level driver.
295 // Reconnect graphics console driver and higher level driver.
296 // Locate all the handles with GOP protocol and reconnect it.
297 //
298 Status = gBS->LocateHandleBuffer (
299 ByProtocol,
300 &gEfiSimpleTextOutProtocolGuid,
301 NULL,
302 &HandleCount,
303 &HandleBuffer
304 );
305 if (!EFI_ERROR (Status)) {
306 for (Index = 0; Index < HandleCount; Index++) {
307 gBS->DisconnectController (HandleBuffer[Index], NULL, NULL);
308 }
309 for (Index = 0; Index < HandleCount; Index++) {
310 gBS->ConnectController (HandleBuffer[Index], NULL, NULL, TRUE);
311 }
312 if (HandleBuffer != NULL) {
313 FreePool (HandleBuffer);
314 }
315 }
316
317 return EFI_SUCCESS;
318 }
319
320 /**
321 This function converts an input device structure to a Unicode string.
322
323 @param DevPath A pointer to the device path structure.
324
325 @return A new allocated Unicode string that represents the device path.
326
327 **/
328 CHAR16 *
329 UiDevicePathToStr (
330 IN EFI_DEVICE_PATH_PROTOCOL *DevPath
331 )
332 {
333 EFI_STATUS Status;
334 CHAR16 *ToText;
335 EFI_DEVICE_PATH_TO_TEXT_PROTOCOL *DevPathToText;
336
337 if (DevPath == NULL) {
338 return NULL;
339 }
340
341 Status = gBS->LocateProtocol (
342 &gEfiDevicePathToTextProtocolGuid,
343 NULL,
344 (VOID **) &DevPathToText
345 );
346 ASSERT_EFI_ERROR (Status);
347 ToText = DevPathToText->ConvertDevicePathToText (
348 DevPath,
349 FALSE,
350 TRUE
351 );
352 ASSERT (ToText != NULL);
353 return ToText;
354 }
355
356 /**
357 Extract filename from device path. The returned buffer is allocated using AllocateCopyPool.
358 The caller is responsible for freeing the allocated buffer using FreePool().
359
360 @param DevicePath Device path.
361
362 @return A new allocated string that represents the file name.
363
364 **/
365 CHAR16 *
366 ExtractFileNameFromDevicePath (
367 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath
368 )
369 {
370 CHAR16 *String;
371 CHAR16 *MatchString;
372 CHAR16 *LastMatch;
373 CHAR16 *FileName;
374 UINTN Length;
375
376 ASSERT(DevicePath != NULL);
377
378 String = UiDevicePathToStr(DevicePath);
379 MatchString = String;
380 LastMatch = String;
381
382 while(MatchString != NULL){
383 LastMatch = MatchString + 1;
384 MatchString = StrStr(LastMatch,L"\\");
385 }
386
387 Length = StrLen(LastMatch);
388 FileName = AllocateCopyPool ((Length + 1) * sizeof(CHAR16), LastMatch);
389 *(FileName + Length) = 0;
390
391 FreePool(String);
392
393 return FileName;
394 }
395
396 /**
397 Extract device path for given HII handle and class guid.
398
399 @param Handle The HII handle.
400
401 @retval NULL Fail to get the device path string.
402 @return PathString Get the device path string.
403
404 **/
405 CHAR16 *
406 BmmExtractDevicePathFromHiiHandle (
407 IN EFI_HII_HANDLE Handle
408 )
409 {
410 EFI_STATUS Status;
411 EFI_HANDLE DriverHandle;
412
413 ASSERT (Handle != NULL);
414
415 if (Handle == NULL) {
416 return NULL;
417 }
418
419 Status = gHiiDatabase->GetPackageListHandle (gHiiDatabase, Handle, &DriverHandle);
420 if (EFI_ERROR (Status)) {
421 return NULL;
422 }
423
424 //
425 // Get device path string.
426 //
427 return ConvertDevicePathToText(DevicePathFromHandle (DriverHandle), FALSE, FALSE);
428
429 }
430
431 /**
432 This function allows a caller to extract the current configuration for one
433 or more named elements from the target driver.
434
435 @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
436 @param Request A null-terminated Unicode string in <ConfigRequest> format.
437 @param Progress On return, points to a character in the Request string.
438 Points to the string's null terminator if request was successful.
439 Points to the most recent '&' before the first failing name/value
440 pair (or the beginning of the string if the failure is in the
441 first name/value pair) if the request was not successful.
442 @param Results A null-terminated Unicode string in <ConfigAltResp> format which
443 has all values filled in for the names in the Request string.
444 String to be allocated by the called function.
445
446 @retval EFI_SUCCESS The Results is filled with the requested values.
447 @retval EFI_OUT_OF_RESOURCES Not enough memory to store the results.
448 @retval EFI_INVALID_PARAMETER Request is NULL, illegal syntax, or unknown name.
449 @retval EFI_NOT_FOUND Routing data doesn't match any storage in this driver.
450
451 **/
452 EFI_STATUS
453 EFIAPI
454 BootMaintExtractConfig (
455 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
456 IN CONST EFI_STRING Request,
457 OUT EFI_STRING *Progress,
458 OUT EFI_STRING *Results
459 )
460 {
461 EFI_STATUS Status;
462 UINTN BufferSize;
463 BMM_CALLBACK_DATA *Private;
464 EFI_STRING ConfigRequestHdr;
465 EFI_STRING ConfigRequest;
466 BOOLEAN AllocatedRequest;
467 UINTN Size;
468
469 if (Progress == NULL || Results == NULL) {
470 return EFI_INVALID_PARAMETER;
471 }
472
473 *Progress = Request;
474 if ((Request != NULL) && !HiiIsConfigHdrMatch (Request, &mBootMaintGuid, mBootMaintStorageName)) {
475 return EFI_NOT_FOUND;
476 }
477
478 ConfigRequestHdr = NULL;
479 ConfigRequest = NULL;
480 AllocatedRequest = FALSE;
481 Size = 0;
482
483 Private = BMM_CALLBACK_DATA_FROM_THIS (This);
484 //
485 // Convert buffer data to <ConfigResp> by helper function BlockToConfig()
486 //
487 BufferSize = sizeof (BMM_FAKE_NV_DATA);
488 ConfigRequest = Request;
489 if ((Request == NULL) || (StrStr (Request, L"OFFSET") == NULL)) {
490 //
491 // Request has no request element, construct full request string.
492 // Allocate and fill a buffer large enough to hold the <ConfigHdr> template
493 // followed by "&OFFSET=0&WIDTH=WWWWWWWWWWWWWWWW" followed by a Null-terminator
494 //
495 ConfigRequestHdr = HiiConstructConfigHdr (&mBootMaintGuid, mBootMaintStorageName, Private->BmmDriverHandle);
496 Size = (StrLen (ConfigRequestHdr) + 32 + 1) * sizeof (CHAR16);
497 ConfigRequest = AllocateZeroPool (Size);
498 ASSERT (ConfigRequest != NULL);
499 AllocatedRequest = TRUE;
500 UnicodeSPrint (ConfigRequest, Size, L"%s&OFFSET=0&WIDTH=%016LX", ConfigRequestHdr, (UINT64)BufferSize);
501 FreePool (ConfigRequestHdr);
502 }
503
504 Status = gHiiConfigRouting->BlockToConfig (
505 gHiiConfigRouting,
506 ConfigRequest,
507 (UINT8 *) &Private->BmmFakeNvData,
508 BufferSize,
509 Results,
510 Progress
511 );
512 //
513 // Free the allocated config request string.
514 //
515 if (AllocatedRequest) {
516 FreePool (ConfigRequest);
517 ConfigRequest = NULL;
518 }
519 //
520 // Set Progress string to the original request string.
521 //
522 if (Request == NULL) {
523 *Progress = NULL;
524 } else if (StrStr (Request, L"OFFSET") == NULL) {
525 *Progress = Request + StrLen (Request);
526 }
527
528 return Status;
529 }
530
531 /**
532 This function applies changes in a driver's configuration.
533 Input is a Configuration, which has the routing data for this
534 driver followed by name / value configuration pairs. The driver
535 must apply those pairs to its configurable storage. If the
536 driver's configuration is stored in a linear block of data
537 and the driver's name / value pairs are in <BlockConfig>
538 format, it may use the ConfigToBlock helper function (above) to
539 simplify the job. Currently not implemented.
540
541 @param[in] This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
542 @param[in] Configuration A null-terminated Unicode string in
543 <ConfigString> format.
544 @param[out] Progress A pointer to a string filled in with the
545 offset of the most recent '&' before the
546 first failing name / value pair (or the
547 beginn ing of the string if the failure
548 is in the first name / value pair) or
549 the terminating NULL if all was
550 successful.
551
552 @retval EFI_SUCCESS The results have been distributed or are
553 awaiting distribution.
554 @retval EFI_OUT_OF_RESOURCES Not enough memory to store the
555 parts of the results that must be
556 stored awaiting possible future
557 protocols.
558 @retval EFI_INVALID_PARAMETERS Passing in a NULL for the
559 Results parameter would result
560 in this type of error.
561 @retval EFI_NOT_FOUND Target for the specified routing data
562 was not found.
563 **/
564 EFI_STATUS
565 EFIAPI
566 BootMaintRouteConfig (
567 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
568 IN CONST EFI_STRING Configuration,
569 OUT EFI_STRING *Progress
570 )
571 {
572 EFI_STATUS Status;
573 UINTN BufferSize;
574 EFI_HII_CONFIG_ROUTING_PROTOCOL *ConfigRouting;
575 BMM_FAKE_NV_DATA *NewBmmData;
576 BMM_FAKE_NV_DATA *OldBmmData;
577 BM_CONSOLE_CONTEXT *NewConsoleContext;
578 BM_TERMINAL_CONTEXT *NewTerminalContext;
579 BM_MENU_ENTRY *NewMenuEntry;
580 BM_LOAD_CONTEXT *NewLoadContext;
581 UINT16 Index;
582 BOOLEAN TerminalAttChange;
583 BMM_CALLBACK_DATA *Private;
584
585 if (Progress == NULL) {
586 return EFI_INVALID_PARAMETER;
587 }
588 *Progress = Configuration;
589
590 if (Configuration == NULL) {
591 return EFI_INVALID_PARAMETER;
592 }
593
594 //
595 // Check routing data in <ConfigHdr>.
596 // Note: there is no name for Name/Value storage, only GUID will be checked
597 //
598 if (!HiiIsConfigHdrMatch (Configuration, &mBootMaintGuid, mBootMaintStorageName)) {
599 return EFI_NOT_FOUND;
600 }
601
602 Status = gBS->LocateProtocol (
603 &gEfiHiiConfigRoutingProtocolGuid,
604 NULL,
605 (VOID **)&ConfigRouting
606 );
607 if (EFI_ERROR (Status)) {
608 return Status;
609 }
610
611 Private = BMM_CALLBACK_DATA_FROM_THIS (This);
612 //
613 // Get Buffer Storage data from EFI variable
614 //
615 BufferSize = sizeof (BMM_FAKE_NV_DATA);
616 OldBmmData = &Private->BmmOldFakeNVData;
617 NewBmmData = &Private->BmmFakeNvData;
618 //
619 // Convert <ConfigResp> to buffer data by helper function ConfigToBlock()
620 //
621 Status = ConfigRouting->ConfigToBlock (
622 ConfigRouting,
623 Configuration,
624 (UINT8 *) NewBmmData,
625 &BufferSize,
626 Progress
627 );
628 ASSERT_EFI_ERROR (Status);
629 //
630 // Compare new and old BMM configuration data and only do action for modified item to
631 // avoid setting unnecessary non-volatile variable
632 //
633
634 //
635 // Check data which located in BMM main page and save the settings if need
636 //
637 if (CompareMem (&NewBmmData->BootNext, &OldBmmData->BootNext, sizeof (NewBmmData->BootNext)) != 0) {
638 Status = Var_UpdateBootNext (Private);
639 }
640
641 //
642 // Check data which located in Boot Options Menu and save the settings if need
643 //
644 if (CompareMem (NewBmmData->BootOptionDel, OldBmmData->BootOptionDel, sizeof (NewBmmData->BootOptionDel)) != 0) {
645 for (Index = 0;
646 ((Index < BootOptionMenu.MenuNumber) && (Index < (sizeof (NewBmmData->BootOptionDel) / sizeof (NewBmmData->BootOptionDel[0]))));
647 Index ++) {
648 NewMenuEntry = BOpt_GetMenuEntry (&BootOptionMenu, Index);
649 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
650 NewLoadContext->Deleted = NewBmmData->BootOptionDel[Index];
651 NewBmmData->BootOptionDel[Index] = FALSE;
652 NewBmmData->BootOptionDelMark[Index] = FALSE;
653 }
654
655 Var_DelBootOption ();
656 }
657
658 if (CompareMem (NewBmmData->BootOptionOrder, OldBmmData->BootOptionOrder, sizeof (NewBmmData->BootOptionOrder)) != 0) {
659 Status = Var_UpdateBootOrder (Private);
660 }
661
662 if (CompareMem (&NewBmmData->BootTimeOut, &OldBmmData->BootTimeOut, sizeof (NewBmmData->BootTimeOut)) != 0){
663 Status = gRT->SetVariable(
664 L"Timeout",
665 &gEfiGlobalVariableGuid,
666 EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
667 sizeof(UINT16),
668 &(NewBmmData->BootTimeOut)
669 );
670 ASSERT_EFI_ERROR(Status);
671
672 Private->BmmOldFakeNVData.BootTimeOut = NewBmmData->BootTimeOut;
673 }
674
675 //
676 // Check data which located in Driver Options Menu and save the settings if need
677 //
678 if (CompareMem (NewBmmData->DriverOptionDel, OldBmmData->DriverOptionDel, sizeof (NewBmmData->DriverOptionDel)) != 0) {
679 for (Index = 0;
680 ((Index < DriverOptionMenu.MenuNumber) && (Index < (sizeof (NewBmmData->DriverOptionDel) / sizeof (NewBmmData->DriverOptionDel[0]))));
681 Index++) {
682 NewMenuEntry = BOpt_GetMenuEntry (&DriverOptionMenu, Index);
683 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
684 NewLoadContext->Deleted = NewBmmData->DriverOptionDel[Index];
685 NewBmmData->DriverOptionDel[Index] = FALSE;
686 NewBmmData->DriverOptionDelMark[Index] = FALSE;
687 }
688 Var_DelDriverOption ();
689 }
690
691 if (CompareMem (NewBmmData->DriverOptionOrder, OldBmmData->DriverOptionOrder, sizeof (NewBmmData->DriverOptionOrder)) != 0) {
692 Status = Var_UpdateDriverOrder (Private);
693 }
694
695 if (CompareMem (&NewBmmData->ConsoleOutMode, &OldBmmData->ConsoleOutMode, sizeof (NewBmmData->ConsoleOutMode)) != 0){
696 Var_UpdateConMode(Private);
697 }
698
699 TerminalAttChange = FALSE;
700 for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
701
702 //
703 // only need update modified items
704 //
705 if (CompareMem (&NewBmmData->COMBaudRate[Index], &OldBmmData->COMBaudRate[Index], sizeof (NewBmmData->COMBaudRate[Index])) == 0 &&
706 CompareMem (&NewBmmData->COMDataRate[Index], &OldBmmData->COMDataRate[Index], sizeof (NewBmmData->COMDataRate[Index])) == 0 &&
707 CompareMem (&NewBmmData->COMStopBits[Index], &OldBmmData->COMStopBits[Index], sizeof (NewBmmData->COMStopBits[Index])) == 0 &&
708 CompareMem (&NewBmmData->COMParity[Index], &OldBmmData->COMParity[Index], sizeof (NewBmmData->COMParity[Index])) == 0 &&
709 CompareMem (&NewBmmData->COMTerminalType[Index], &OldBmmData->COMTerminalType[Index], sizeof (NewBmmData->COMTerminalType[Index])) == 0 &&
710 CompareMem (&NewBmmData->COMFlowControl[Index], &OldBmmData->COMFlowControl[Index], sizeof (NewBmmData->COMFlowControl[Index])) == 0) {
711 continue;
712 }
713
714 NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Index);
715 ASSERT (NewMenuEntry != NULL);
716 NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
717 NewTerminalContext->BaudRateIndex = NewBmmData->COMBaudRate[Index];
718 ASSERT (NewBmmData->COMBaudRate[Index] < (sizeof (BaudRateList) / sizeof (BaudRateList[0])));
719 NewTerminalContext->BaudRate = BaudRateList[NewBmmData->COMBaudRate[Index]].Value;
720 NewTerminalContext->DataBitsIndex = NewBmmData->COMDataRate[Index];
721 ASSERT (NewBmmData->COMDataRate[Index] < (sizeof (DataBitsList) / sizeof (DataBitsList[0])));
722 NewTerminalContext->DataBits = (UINT8) DataBitsList[NewBmmData->COMDataRate[Index]].Value;
723 NewTerminalContext->StopBitsIndex = NewBmmData->COMStopBits[Index];
724 ASSERT (NewBmmData->COMStopBits[Index] < (sizeof (StopBitsList) / sizeof (StopBitsList[0])));
725 NewTerminalContext->StopBits = (UINT8) StopBitsList[NewBmmData->COMStopBits[Index]].Value;
726 NewTerminalContext->ParityIndex = NewBmmData->COMParity[Index];
727 ASSERT (NewBmmData->COMParity[Index] < (sizeof (ParityList) / sizeof (ParityList[0])));
728 NewTerminalContext->Parity = (UINT8) ParityList[NewBmmData->COMParity[Index]].Value;
729 NewTerminalContext->TerminalType = NewBmmData->COMTerminalType[Index];
730 NewTerminalContext->FlowControl = NewBmmData->COMFlowControl[Index];
731 ChangeTerminalDevicePath (
732 NewTerminalContext->DevicePath,
733 FALSE
734 );
735 TerminalAttChange = TRUE;
736 }
737 if (TerminalAttChange) {
738 Var_UpdateConsoleInpOption ();
739 Var_UpdateConsoleOutOption ();
740 Var_UpdateErrorOutOption ();
741 }
742 //
743 // Check data which located in Console Options Menu and save the settings if need
744 //
745 if (CompareMem (NewBmmData->ConsoleInCheck, OldBmmData->ConsoleInCheck, sizeof (NewBmmData->ConsoleInCheck)) != 0){
746 for (Index = 0; Index < ConsoleInpMenu.MenuNumber; Index++){
747 NewMenuEntry = BOpt_GetMenuEntry(&ConsoleInpMenu, Index);
748 NewConsoleContext = (BM_CONSOLE_CONTEXT *)NewMenuEntry->VariableContext;
749 ASSERT (Index < MAX_MENU_NUMBER);
750 NewConsoleContext->IsActive = NewBmmData->ConsoleInCheck[Index];
751 }
752 for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
753 NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Index);
754 NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
755 ASSERT (Index + ConsoleInpMenu.MenuNumber < MAX_MENU_NUMBER);
756 NewTerminalContext->IsConIn = NewBmmData->ConsoleInCheck[Index + ConsoleInpMenu.MenuNumber];
757 }
758 Var_UpdateConsoleInpOption();
759 }
760
761 if (CompareMem (NewBmmData->ConsoleOutCheck, OldBmmData->ConsoleOutCheck, sizeof (NewBmmData->ConsoleOutCheck)) != 0){
762 for (Index = 0; Index < ConsoleOutMenu.MenuNumber; Index++){
763 NewMenuEntry = BOpt_GetMenuEntry(&ConsoleOutMenu, Index);
764 NewConsoleContext = (BM_CONSOLE_CONTEXT *)NewMenuEntry->VariableContext;
765 ASSERT (Index < MAX_MENU_NUMBER);
766 NewConsoleContext->IsActive = NewBmmData->ConsoleOutCheck[Index];
767 }
768 for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
769 NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Index);
770 NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
771 ASSERT (Index + ConsoleOutMenu.MenuNumber < MAX_MENU_NUMBER);
772 NewTerminalContext->IsConOut = NewBmmData->ConsoleOutCheck[Index + ConsoleOutMenu.MenuNumber];
773 }
774 Var_UpdateConsoleOutOption();
775 }
776
777 if (CompareMem (NewBmmData->ConsoleErrCheck, OldBmmData->ConsoleErrCheck, sizeof (NewBmmData->ConsoleErrCheck)) != 0){
778 for (Index = 0; Index < ConsoleErrMenu.MenuNumber; Index++){
779 NewMenuEntry = BOpt_GetMenuEntry(&ConsoleErrMenu, Index);
780 NewConsoleContext = (BM_CONSOLE_CONTEXT *)NewMenuEntry->VariableContext;
781 ASSERT (Index < MAX_MENU_NUMBER);
782 NewConsoleContext->IsActive = NewBmmData->ConsoleErrCheck[Index];
783 }
784 for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
785 NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Index);
786 NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
787 ASSERT (Index + ConsoleErrMenu.MenuNumber < MAX_MENU_NUMBER);
788 NewTerminalContext->IsStdErr = NewBmmData->ConsoleErrCheck[Index + ConsoleErrMenu.MenuNumber];
789 }
790 Var_UpdateErrorOutOption();
791 }
792
793 if (CompareMem (NewBmmData->BootDescriptionData, OldBmmData->BootDescriptionData, sizeof (NewBmmData->BootDescriptionData)) != 0 ||
794 CompareMem (NewBmmData->BootOptionalData, OldBmmData->BootOptionalData, sizeof (NewBmmData->BootOptionalData)) != 0) {
795 Status = Var_UpdateBootOption (Private);
796 NewBmmData->BootOptionChanged = FALSE;
797 if (EFI_ERROR (Status)) {
798 return Status;
799 }
800 BOpt_GetBootOptions (Private);
801 }
802
803 if (CompareMem (NewBmmData->DriverDescriptionData, OldBmmData->DriverDescriptionData, sizeof (NewBmmData->DriverDescriptionData)) != 0 ||
804 CompareMem (NewBmmData->DriverOptionalData, OldBmmData->DriverOptionalData, sizeof (NewBmmData->DriverOptionalData)) != 0) {
805 Status = Var_UpdateDriverOption (
806 Private,
807 Private->BmmHiiHandle,
808 NewBmmData->DriverDescriptionData,
809 NewBmmData->DriverOptionalData,
810 NewBmmData->ForceReconnect
811 );
812 NewBmmData->DriverOptionChanged = FALSE;
813 NewBmmData->ForceReconnect = TRUE;
814 if (EFI_ERROR (Status)) {
815 return Status;
816 }
817
818 BOpt_GetDriverOptions (Private);
819 }
820
821 //
822 // After user do the save action, need to update OldBmmData.
823 //
824 CopyMem (OldBmmData, NewBmmData, sizeof (BMM_FAKE_NV_DATA));
825
826 return EFI_SUCCESS;
827 }
828
829 /**
830 This function processes the results of changes in configuration.
831
832
833 @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
834 @param Action Specifies the type of action taken by the browser.
835 @param QuestionId A unique value which is sent to the original exporting driver
836 so that it can identify the type of data to expect.
837 @param Type The type of value for the question.
838 @param Value A pointer to the data being sent to the original exporting driver.
839 @param ActionRequest On return, points to the action requested by the callback function.
840
841 @retval EFI_SUCCESS The callback successfully handled the action.
842 @retval EFI_OUT_OF_RESOURCES Not enough storage is available to hold the variable and its data.
843 @retval EFI_DEVICE_ERROR The variable could not be saved.
844 @retval EFI_UNSUPPORTED The specified Action is not supported by the callback.
845 @retval EFI_INVALID_PARAMETER The parameter of Value or ActionRequest is invalid.
846 **/
847 EFI_STATUS
848 EFIAPI
849 BootMaintCallback (
850 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
851 IN EFI_BROWSER_ACTION Action,
852 IN EFI_QUESTION_ID QuestionId,
853 IN UINT8 Type,
854 IN EFI_IFR_TYPE_VALUE *Value,
855 OUT EFI_BROWSER_ACTION_REQUEST *ActionRequest
856 )
857 {
858 BMM_CALLBACK_DATA *Private;
859 BM_MENU_ENTRY *NewMenuEntry;
860 BMM_FAKE_NV_DATA *CurrentFakeNVMap;
861 UINTN OldValue;
862 UINTN NewValue;
863 UINTN Number;
864 UINTN Index;
865 EFI_DEVICE_PATH_PROTOCOL * File;
866
867 if (Action != EFI_BROWSER_ACTION_CHANGING && Action != EFI_BROWSER_ACTION_CHANGED) {
868 //
869 // Do nothing for other UEFI Action. Only do call back when data is changed.
870 //
871 return EFI_UNSUPPORTED;
872 }
873 OldValue = 0;
874 NewValue = 0;
875 Number = 0;
876
877 Private = BMM_CALLBACK_DATA_FROM_THIS (This);
878 //
879 // Retrive uncommitted data from Form Browser
880 //
881 CurrentFakeNVMap = &Private->BmmFakeNvData;
882 HiiGetBrowserData (&mBootMaintGuid, mBootMaintStorageName, sizeof (BMM_FAKE_NV_DATA), (UINT8 *) CurrentFakeNVMap);
883
884 if (Action == EFI_BROWSER_ACTION_CHANGING) {
885 if (Value == NULL) {
886 return EFI_INVALID_PARAMETER;
887 }
888
889 UpdatePageId (Private, QuestionId);
890
891 if (QuestionId < FILE_OPTION_OFFSET) {
892 if (QuestionId < CONFIG_OPTION_OFFSET) {
893 switch (QuestionId) {
894 case FORM_BOOT_ADD_ID:
895 // Leave BMM and enter FileExplorer.
896 ChooseFile( NULL, L".efi", (CHOOSE_HANDLER) CreateBootOptionFromFile, &File);
897 break;
898
899 case FORM_DRV_ADD_FILE_ID:
900 // Leave BMM and enter FileExplorer.
901 ChooseFile( NULL, L".efi", (CHOOSE_HANDLER) CreateDriverOptionFromFile, &File);
902 break;
903
904 case FORM_DRV_ADD_HANDLE_ID:
905 CleanUpPage (FORM_DRV_ADD_HANDLE_ID, Private);
906 UpdateDrvAddHandlePage (Private);
907 break;
908
909 case FORM_BOOT_DEL_ID:
910 CleanUpPage (FORM_BOOT_DEL_ID, Private);
911 UpdateBootDelPage (Private);
912 break;
913
914 case FORM_BOOT_CHG_ID:
915 case FORM_DRV_CHG_ID:
916 UpdatePageBody (QuestionId, Private);
917 break;
918
919 case FORM_DRV_DEL_ID:
920 CleanUpPage (FORM_DRV_DEL_ID, Private);
921 UpdateDrvDelPage (Private);
922 break;
923
924 case FORM_BOOT_NEXT_ID:
925 CleanUpPage (FORM_BOOT_NEXT_ID, Private);
926 UpdateBootNextPage (Private);
927 break;
928
929 case FORM_TIME_OUT_ID:
930 CleanUpPage (FORM_TIME_OUT_ID, Private);
931 UpdateTimeOutPage (Private);
932 break;
933
934 case FORM_CON_IN_ID:
935 case FORM_CON_OUT_ID:
936 case FORM_CON_ERR_ID:
937 UpdatePageBody (QuestionId, Private);
938 break;
939
940 case FORM_CON_MODE_ID:
941 CleanUpPage (FORM_CON_MODE_ID, Private);
942 UpdateConModePage (Private);
943 break;
944
945 case FORM_CON_COM_ID:
946 CleanUpPage (FORM_CON_COM_ID, Private);
947 UpdateConCOMPage (Private);
948 break;
949
950 default:
951 break;
952 }
953 } else if ((QuestionId >= TERMINAL_OPTION_OFFSET) && (QuestionId < CONSOLE_OPTION_OFFSET)) {
954 Index = (UINT16) (QuestionId - TERMINAL_OPTION_OFFSET);
955 Private->CurrentTerminal = Index;
956
957 CleanUpPage (FORM_CON_COM_SETUP_ID, Private);
958 UpdateTerminalPage (Private);
959
960 } else if (QuestionId >= HANDLE_OPTION_OFFSET) {
961 Index = (UINT16) (QuestionId - HANDLE_OPTION_OFFSET);
962
963 NewMenuEntry = BOpt_GetMenuEntry (&DriverMenu, Index);
964 ASSERT (NewMenuEntry != NULL);
965 Private->HandleContext = (BM_HANDLE_CONTEXT *) NewMenuEntry->VariableContext;
966
967 CleanUpPage (FORM_DRV_ADD_HANDLE_DESC_ID, Private);
968
969 Private->MenuEntry = NewMenuEntry;
970 Private->LoadContext->FilePathList = Private->HandleContext->DevicePath;
971
972 UpdateDriverAddHandleDescPage (Private);
973 }
974 }
975 if (QuestionId == KEY_VALUE_BOOT_FROM_FILE){
976 // Leave BMM and enter FileExplorer.
977 ChooseFile( NULL, L".efi", (CHOOSE_HANDLER) BootFromFile, &File);
978 }
979 } else if (Action == EFI_BROWSER_ACTION_CHANGED) {
980 if ((Value == NULL) || (ActionRequest == NULL)) {
981 return EFI_INVALID_PARAMETER;
982 }
983
984 if (QuestionId == KEY_VALUE_SAVE_AND_EXIT_BOOT) {
985 CurrentFakeNVMap->BootOptionChanged = FALSE;
986 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_SUBMIT_EXIT;
987 } else if (QuestionId == KEY_VALUE_SAVE_AND_EXIT_DRIVER) {
988 CurrentFakeNVMap->DriverOptionChanged = FALSE;
989 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_SUBMIT_EXIT;
990 } else if (QuestionId == KEY_VALUE_NO_SAVE_AND_EXIT_DRIVER) {
991 //
992 // Discard changes and exit formset
993 //
994 CurrentFakeNVMap->DriverOptionalData[0] = 0x0000;
995 CurrentFakeNVMap->DriverDescriptionData[0] = 0x0000;
996 CurrentFakeNVMap->DriverOptionChanged = FALSE;
997 CurrentFakeNVMap->ForceReconnect = TRUE;
998 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_DISCARD_EXIT;
999 } else if (QuestionId == KEY_VALUE_NO_SAVE_AND_EXIT_BOOT) {
1000 //
1001 // Discard changes and exit formset
1002 //
1003 CurrentFakeNVMap->BootOptionalData[0] = 0x0000;
1004 CurrentFakeNVMap->BootDescriptionData[0] = 0x0000;
1005 CurrentFakeNVMap->BootOptionChanged = FALSE;
1006 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_DISCARD_EXIT;
1007 } else if (QuestionId == KEY_VALUE_BOOT_DESCRIPTION || QuestionId == KEY_VALUE_BOOT_OPTION) {
1008 CurrentFakeNVMap->BootOptionChanged = TRUE;
1009 } else if (QuestionId == KEY_VALUE_DRIVER_DESCRIPTION || QuestionId == KEY_VALUE_DRIVER_OPTION) {
1010 CurrentFakeNVMap->DriverOptionChanged = TRUE;
1011 }
1012
1013 if ((QuestionId >= BOOT_OPTION_DEL_QUESTION_ID) && (QuestionId < BOOT_OPTION_DEL_QUESTION_ID + MAX_MENU_NUMBER)) {
1014 if (Value->b){
1015 //
1016 // Means user try to delete this boot option but not press F10 or "Commit Changes and Exit" menu.
1017 //
1018 CurrentFakeNVMap->BootOptionDelMark[QuestionId - BOOT_OPTION_DEL_QUESTION_ID] = TRUE;
1019 } else {
1020 //
1021 // Means user remove the old check status.
1022 //
1023 CurrentFakeNVMap->BootOptionDelMark[QuestionId - BOOT_OPTION_DEL_QUESTION_ID] = FALSE;
1024 }
1025 } else if ((QuestionId >= DRIVER_OPTION_DEL_QUESTION_ID) && (QuestionId < DRIVER_OPTION_DEL_QUESTION_ID + MAX_MENU_NUMBER)) {
1026 if (Value->b){
1027 CurrentFakeNVMap->DriverOptionDelMark[QuestionId - DRIVER_OPTION_DEL_QUESTION_ID] = TRUE;
1028 } else {
1029 CurrentFakeNVMap->DriverOptionDelMark[QuestionId - DRIVER_OPTION_DEL_QUESTION_ID] = FALSE;
1030 }
1031 } else {
1032 switch (QuestionId) {
1033 case KEY_VALUE_SAVE_AND_EXIT:
1034 case KEY_VALUE_NO_SAVE_AND_EXIT:
1035 if (QuestionId == KEY_VALUE_SAVE_AND_EXIT) {
1036 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_SUBMIT_EXIT;
1037 } else if (QuestionId == KEY_VALUE_NO_SAVE_AND_EXIT) {
1038 DiscardChangeHandler (Private, CurrentFakeNVMap);
1039 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_DISCARD_EXIT;
1040 }
1041
1042 break;
1043
1044 case FORM_RESET:
1045 gRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL);
1046 return EFI_UNSUPPORTED;
1047
1048 default:
1049 break;
1050 }
1051 }
1052 }
1053
1054 //
1055 // Pass changed uncommitted data back to Form Browser
1056 //
1057 HiiSetBrowserData (&mBootMaintGuid, mBootMaintStorageName, sizeof (BMM_FAKE_NV_DATA), (UINT8 *) CurrentFakeNVMap, NULL);
1058
1059 return EFI_SUCCESS;
1060 }
1061
1062 /**
1063 Discard all changes done to the BMM pages such as Boot Order change,
1064 Driver order change.
1065
1066 @param Private The BMM context data.
1067 @param CurrentFakeNVMap The current Fack NV Map.
1068
1069 **/
1070 VOID
1071 DiscardChangeHandler (
1072 IN BMM_CALLBACK_DATA *Private,
1073 IN BMM_FAKE_NV_DATA *CurrentFakeNVMap
1074 )
1075 {
1076 UINT16 Index;
1077
1078 switch (Private->BmmPreviousPageId) {
1079 case FORM_BOOT_CHG_ID:
1080 CopyMem (CurrentFakeNVMap->BootOptionOrder, Private->BmmOldFakeNVData.BootOptionOrder, sizeof (CurrentFakeNVMap->BootOptionOrder));
1081 break;
1082
1083 case FORM_DRV_CHG_ID:
1084 CopyMem (CurrentFakeNVMap->DriverOptionOrder, Private->BmmOldFakeNVData.DriverOptionOrder, sizeof (CurrentFakeNVMap->DriverOptionOrder));
1085 break;
1086
1087 case FORM_BOOT_DEL_ID:
1088 ASSERT (BootOptionMenu.MenuNumber <= (sizeof (CurrentFakeNVMap->BootOptionDel) / sizeof (CurrentFakeNVMap->BootOptionDel[0])));
1089 for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
1090 CurrentFakeNVMap->BootOptionDel[Index] = FALSE;
1091 }
1092 break;
1093
1094 case FORM_DRV_DEL_ID:
1095 ASSERT (DriverOptionMenu.MenuNumber <= (sizeof (CurrentFakeNVMap->DriverOptionDel) / sizeof (CurrentFakeNVMap->DriverOptionDel[0])));
1096 for (Index = 0; Index < DriverOptionMenu.MenuNumber; Index++) {
1097 CurrentFakeNVMap->DriverOptionDel[Index] = FALSE;
1098 }
1099 break;
1100
1101 case FORM_BOOT_NEXT_ID:
1102 CurrentFakeNVMap->BootNext = Private->BmmOldFakeNVData.BootNext;
1103 break;
1104
1105 case FORM_TIME_OUT_ID:
1106 CurrentFakeNVMap->BootTimeOut = Private->BmmOldFakeNVData.BootTimeOut;
1107 break;
1108
1109 case FORM_DRV_ADD_HANDLE_DESC_ID:
1110 case FORM_DRV_ADD_FILE_ID:
1111 case FORM_DRV_ADD_HANDLE_ID:
1112 CurrentFakeNVMap->DriverAddHandleDesc[0] = 0x0000;
1113 CurrentFakeNVMap->DriverAddHandleOptionalData[0] = 0x0000;
1114 break;
1115
1116 default:
1117 break;
1118 }
1119 }
1120
1121 /**
1122 Create dynamic code for BMM.
1123
1124 @param BmmCallbackInfo The BMM context data.
1125
1126 **/
1127 VOID
1128 InitializeDrivers(
1129 IN BMM_CALLBACK_DATA *BmmCallbackInfo
1130 )
1131 {
1132 EFI_HII_HANDLE HiiHandle;
1133 VOID *StartOpCodeHandle;
1134 VOID *EndOpCodeHandle;
1135 EFI_IFR_GUID_LABEL *StartLabel;
1136 EFI_IFR_GUID_LABEL *EndLabel;
1137 UINTN Index;
1138 EFI_STRING String;
1139 EFI_STRING_ID Token;
1140 EFI_STRING_ID TokenHelp;
1141 EFI_HII_HANDLE *HiiHandles;
1142 EFI_GUID FormSetGuid;
1143 CHAR16 *DevicePathStr;
1144 EFI_STRING_ID DevicePathId;
1145 EFI_IFR_FORM_SET *Buffer;
1146 UINTN BufferSize;
1147 UINT8 ClassGuidNum;
1148 EFI_GUID *ClassGuid;
1149 UINTN TempSize;
1150 UINT8 *Ptr;
1151 EFI_STATUS Status;
1152
1153 TempSize =0;
1154 BufferSize = 0;
1155 Buffer = NULL;
1156
1157 HiiHandle = BmmCallbackInfo->BmmHiiHandle;
1158 //
1159 // Allocate space for creation of UpdateData Buffer
1160 //
1161 StartOpCodeHandle = HiiAllocateOpCodeHandle ();
1162 ASSERT (StartOpCodeHandle != NULL);
1163
1164 EndOpCodeHandle = HiiAllocateOpCodeHandle ();
1165 ASSERT (EndOpCodeHandle != NULL);
1166
1167 //
1168 // Create Hii Extend Label OpCode as the start opcode
1169 //
1170 StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (StartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
1171 StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
1172 StartLabel->Number = LABEL_BMM_PLATFORM_INFORMATION;
1173
1174 //
1175 // Create Hii Extend Label OpCode as the end opcode
1176 //
1177 EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (EndOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
1178 EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
1179 EndLabel->Number = LABEL_END;
1180
1181 //
1182 // Get all the Hii handles
1183 //
1184 HiiHandles = HiiGetHiiHandles (NULL);
1185 ASSERT (HiiHandles != NULL);
1186
1187 //
1188 // Search for formset of each class type
1189 //
1190 for (Index = 0; HiiHandles[Index] != NULL; Index++) {
1191 Status = HiiGetFormSetFromHiiHandle(HiiHandles[Index], &Buffer,&BufferSize);
1192 if (EFI_ERROR (Status)) {
1193 continue;
1194 }
1195
1196 Ptr = (UINT8 *)Buffer;
1197 while(TempSize < BufferSize) {
1198 TempSize += ((EFI_IFR_OP_HEADER *) Ptr)->Length;
1199
1200 if (((EFI_IFR_OP_HEADER *) Ptr)->Length <= OFFSET_OF (EFI_IFR_FORM_SET, Flags)){
1201 Ptr += ((EFI_IFR_OP_HEADER *) Ptr)->Length;
1202 continue;
1203 }
1204
1205 //
1206 // Find FormSet OpCode
1207 //
1208 ClassGuidNum = (UINT8) (((EFI_IFR_FORM_SET *)Ptr)->Flags & 0x3);
1209 ClassGuid = (EFI_GUID *) (VOID *)(Ptr + sizeof (EFI_IFR_FORM_SET));
1210 while (ClassGuidNum-- > 0) {
1211 if (CompareGuid (&gEfiIfrBootMaintenanceGuid, ClassGuid) == 0){
1212 ClassGuid ++;
1213 continue;
1214 }
1215
1216 String = HiiGetString (HiiHandles[Index], ((EFI_IFR_FORM_SET *)Ptr)->FormSetTitle, NULL);
1217 if (String == NULL) {
1218 String = HiiGetString (HiiHandle, STRING_TOKEN (STR_MISSING_STRING), NULL);
1219 ASSERT (String != NULL);
1220 }
1221 Token = HiiSetString (HiiHandle, 0, String, NULL);
1222 FreePool (String);
1223
1224 String = HiiGetString (HiiHandles[Index], ((EFI_IFR_FORM_SET *)Ptr)->Help, NULL);
1225 if (String == NULL) {
1226 String = HiiGetString (HiiHandle, STRING_TOKEN (STR_MISSING_STRING), NULL);
1227 ASSERT (String != NULL);
1228 }
1229 TokenHelp = HiiSetString (HiiHandle, 0, String, NULL);
1230 FreePool (String);
1231
1232 FormSetGuid = ((EFI_IFR_FORM_SET *)Ptr)->Guid;
1233
1234 DevicePathStr = BmmExtractDevicePathFromHiiHandle(HiiHandles[Index]);
1235 DevicePathId = 0;
1236 if (DevicePathStr != NULL){
1237 DevicePathId = HiiSetString (HiiHandle, 0, DevicePathStr, NULL);
1238 FreePool (DevicePathStr);
1239 }
1240 HiiCreateGotoExOpCode (
1241 StartOpCodeHandle,
1242 0,
1243 Token,
1244 TokenHelp,
1245 0,
1246 (EFI_QUESTION_ID) (Index + FRONT_PAGE_KEY_OFFSET),
1247 0,
1248 &FormSetGuid,
1249 DevicePathId
1250 );
1251 break;
1252 }
1253 Ptr += ((EFI_IFR_OP_HEADER *) Ptr)->Length;
1254 }
1255
1256 FreePool(Buffer);
1257 Buffer = NULL;
1258 TempSize = 0;
1259 BufferSize = 0;
1260 }
1261
1262 HiiUpdateForm (
1263 HiiHandle,
1264 &mBootMaintGuid,
1265 FORM_MAIN_ID,
1266 StartOpCodeHandle,
1267 EndOpCodeHandle
1268 );
1269
1270 HiiFreeOpCodeHandle (StartOpCodeHandle);
1271 HiiFreeOpCodeHandle (EndOpCodeHandle);
1272 FreePool (HiiHandles);
1273 }
1274
1275 /**
1276 Create dynamic code for BMM and initialize all of BMM configuration data in BmmFakeNvData and
1277 BmmOldFakeNVData member in BMM context data.
1278
1279 @param CallbackData The BMM context data.
1280
1281 **/
1282 VOID
1283 InitializeBmmConfig (
1284 IN BMM_CALLBACK_DATA *CallbackData
1285 )
1286 {
1287 BM_MENU_ENTRY *NewMenuEntry;
1288 BM_LOAD_CONTEXT *NewLoadContext;
1289 UINT16 Index;
1290
1291 ASSERT (CallbackData != NULL);
1292
1293 InitializeDrivers (CallbackData);
1294
1295 //
1296 // Initialize data which located in BMM main page
1297 //
1298 CallbackData->BmmFakeNvData.BootNext = NONE_BOOTNEXT_VALUE;
1299 for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
1300 NewMenuEntry = BOpt_GetMenuEntry (&BootOptionMenu, Index);
1301 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
1302
1303 if (NewLoadContext->IsBootNext) {
1304 CallbackData->BmmFakeNvData.BootNext = Index;
1305 break;
1306 }
1307 }
1308
1309 CallbackData->BmmFakeNvData.BootTimeOut = PcdGet16 (PcdPlatformBootTimeOut);
1310
1311 //
1312 // Initialize data which located in Boot Options Menu
1313 //
1314 GetBootOrder (CallbackData);
1315
1316 //
1317 // Initialize data which located in Driver Options Menu
1318 //
1319 GetDriverOrder (CallbackData);
1320
1321 //
1322 // Initialize data which located in Console Options Menu
1323 //
1324 GetConsoleOutMode (CallbackData);
1325 GetConsoleInCheck (CallbackData);
1326 GetConsoleOutCheck (CallbackData);
1327 GetConsoleErrCheck (CallbackData);
1328 GetTerminalAttribute (CallbackData);
1329
1330 CallbackData->BmmFakeNvData.ForceReconnect = TRUE;
1331
1332 //
1333 // Backup Initialize BMM configuartion data to BmmOldFakeNVData
1334 //
1335 CopyMem (&CallbackData->BmmOldFakeNVData, &CallbackData->BmmFakeNvData, sizeof (BMM_FAKE_NV_DATA));
1336 }
1337
1338 /**
1339 Initialized all Menu Option List.
1340
1341 @param CallbackData The BMM context data.
1342
1343 **/
1344 VOID
1345 InitAllMenu (
1346 IN BMM_CALLBACK_DATA *CallbackData
1347 )
1348 {
1349 InitializeListHead (&BootOptionMenu.Head);
1350 InitializeListHead (&DriverOptionMenu.Head);
1351 BOpt_GetBootOptions (CallbackData);
1352 BOpt_GetDriverOptions (CallbackData);
1353 BOpt_FindDrivers ();
1354 InitializeListHead (&ConsoleInpMenu.Head);
1355 InitializeListHead (&ConsoleOutMenu.Head);
1356 InitializeListHead (&ConsoleErrMenu.Head);
1357 InitializeListHead (&TerminalMenu.Head);
1358 LocateSerialIo ();
1359 GetAllConsoles ();
1360 mAllMenuInit = TRUE;
1361 }
1362
1363 /**
1364 Free up all Menu Option list.
1365
1366 **/
1367 VOID
1368 FreeAllMenu (
1369 VOID
1370 )
1371 {
1372 if (!mAllMenuInit){
1373 return;
1374 }
1375 BOpt_FreeMenu (&BootOptionMenu);
1376 BOpt_FreeMenu (&DriverOptionMenu);
1377 BOpt_FreeMenu (&DriverMenu);
1378 FreeAllConsoles ();
1379 mAllMenuInit = FALSE;
1380 }
1381
1382 /**
1383
1384 Install Boot Maintenance Manager Menu driver.
1385
1386 @param ImageHandle The image handle.
1387 @param SystemTable The system table.
1388
1389 @retval EFI_SUCEESS Install Boot manager menu success.
1390 @retval Other Return error status.
1391
1392 **/
1393 EFI_STATUS
1394 EFIAPI
1395 BootMaintenanceManagerLibConstructor (
1396 IN EFI_HANDLE ImageHandle,
1397 IN EFI_SYSTEM_TABLE *SystemTable
1398 )
1399
1400 {
1401 EFI_STATUS Status;
1402 UINT8 *Ptr;
1403
1404 Status = EFI_SUCCESS;
1405
1406 //
1407 // Install Device Path Protocol and Config Access protocol to driver handle
1408 //
1409 Status = gBS->InstallMultipleProtocolInterfaces (
1410 &mBmmCallbackInfo->BmmDriverHandle,
1411 &gEfiDevicePathProtocolGuid,
1412 &mBmmHiiVendorDevicePath,
1413 &gEfiHiiConfigAccessProtocolGuid,
1414 &mBmmCallbackInfo->BmmConfigAccess,
1415 NULL
1416 );
1417 ASSERT_EFI_ERROR (Status);
1418
1419 //
1420 // Post our Boot Maint VFR binary to the HII database.
1421 //
1422 mBmmCallbackInfo->BmmHiiHandle = HiiAddPackages (
1423 &mBootMaintGuid,
1424 mBmmCallbackInfo->BmmDriverHandle,
1425 BootMaintenanceManagerBin,
1426 BootMaintenanceManagerLibStrings,
1427 NULL
1428 );
1429 ASSERT (mBmmCallbackInfo->BmmHiiHandle != NULL);
1430
1431 //
1432 // Locate Formbrowser2 protocol
1433 //
1434 Status = gBS->LocateProtocol (&gEfiFormBrowser2ProtocolGuid, NULL, (VOID **) &mBmmCallbackInfo->FormBrowser2);
1435 ASSERT_EFI_ERROR (Status);
1436
1437 EfiBootManagerRefreshAllBootOption ();
1438
1439 //
1440 // Create LoadOption in BmmCallbackInfo for Driver Callback
1441 //
1442 Ptr = AllocateZeroPool (sizeof (BM_LOAD_CONTEXT) + sizeof (BM_FILE_CONTEXT) + sizeof (BM_HANDLE_CONTEXT) + sizeof (BM_MENU_ENTRY));
1443 ASSERT (Ptr != NULL);
1444
1445 //
1446 // Initialize Bmm callback data.
1447 //
1448 mBmmCallbackInfo->LoadContext = (BM_LOAD_CONTEXT *) Ptr;
1449 Ptr += sizeof (BM_LOAD_CONTEXT);
1450
1451 mBmmCallbackInfo->FileContext = (BM_FILE_CONTEXT *) Ptr;
1452 Ptr += sizeof (BM_FILE_CONTEXT);
1453
1454 mBmmCallbackInfo->HandleContext = (BM_HANDLE_CONTEXT *) Ptr;
1455 Ptr += sizeof (BM_HANDLE_CONTEXT);
1456
1457 mBmmCallbackInfo->MenuEntry = (BM_MENU_ENTRY *) Ptr;
1458
1459 mBmmCallbackInfo->BmmPreviousPageId = FORM_MAIN_ID;
1460 mBmmCallbackInfo->BmmCurrentPageId = FORM_MAIN_ID;
1461
1462 InitAllMenu (mBmmCallbackInfo);
1463
1464 CreateUpdateData();
1465 //
1466 // Update boot maintenance manager page
1467 //
1468 InitializeBmmConfig(mBmmCallbackInfo);
1469
1470 return EFI_SUCCESS;
1471 }
1472
1473 /**
1474 Unloads the application and its installed protocol.
1475
1476 @param ImageHandle Handle that identifies the image to be unloaded.
1477 @param SystemTable The system table.
1478
1479 @retval EFI_SUCCESS The image has been unloaded.
1480
1481 **/
1482 EFI_STATUS
1483 EFIAPI
1484 BootMaintenanceManagerLibDestructor (
1485 IN EFI_HANDLE ImageHandle,
1486 IN EFI_SYSTEM_TABLE *SystemTable
1487 )
1488
1489 {
1490 if (mStartOpCodeHandle != NULL) {
1491 HiiFreeOpCodeHandle (mStartOpCodeHandle);
1492 }
1493
1494 if (mEndOpCodeHandle != NULL) {
1495 HiiFreeOpCodeHandle (mEndOpCodeHandle);
1496 }
1497
1498 FreeAllMenu ();
1499
1500 //
1501 // Remove our IFR data from HII database
1502 //
1503 HiiRemovePackages (mBmmCallbackInfo->BmmHiiHandle);
1504
1505 gBS->UninstallMultipleProtocolInterfaces (
1506 mBmmCallbackInfo->BmmDriverHandle,
1507 &gEfiDevicePathProtocolGuid,
1508 &mBmmHiiVendorDevicePath,
1509 &gEfiHiiConfigAccessProtocolGuid,
1510 &mBmmCallbackInfo->BmmConfigAccess,
1511 NULL
1512 );
1513
1514 FreePool (mBmmCallbackInfo->LoadContext);
1515
1516 return EFI_SUCCESS;
1517 }
1518