VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/OvmfPkg/Csm/LegacyBootMaintUiLib/LegacyBootMaintUi.c@ 81913

Last change on this file since 81913 was 80721, checked in by vboxsync, 5 years ago

Devices/EFI/FirmwareNew: Start upgrade process to edk2-stable201908 (compiles on Windows and works to some extent), bugref:4643
  • Property svn:eol-style set to native
File size: 46.3 KB
Line 
1/** @file
2 Legacy Boot Maintainence UI implementation.
3
4Copyright (c) 2004 - 2018, Intel Corporation. All rights reserved.<BR>
5(C) Copyright 2018 Hewlett Packard Enterprise Development LP<BR>
6SPDX-License-Identifier: BSD-2-Clause-Patent
7
8**/
9
10
11#include "LegacyBootMaintUi.h"
12
13LEGACY_BOOT_OPTION_CALLBACK_DATA *mLegacyBootOptionPrivate = NULL;
14EFI_GUID mLegacyBootOptionGuid = LEGACY_BOOT_OPTION_FORMSET_GUID;
15CHAR16 mLegacyBootStorageName[] = L"LegacyBootData";
16BBS_TYPE mBbsType[] = {BBS_FLOPPY, BBS_HARDDISK, BBS_CDROM, BBS_EMBED_NETWORK, BBS_BEV_DEVICE, BBS_UNKNOWN};
17BOOLEAN mFirstEnterLegacyForm = FALSE;
18
19
20///
21/// Legacy FD Info from LegacyBios.GetBbsInfo()
22///
23LEGACY_MENU_OPTION LegacyFDMenu = {
24 LEGACY_MENU_OPTION_SIGNATURE,
25 {NULL},
26 0
27};
28
29///
30/// Legacy HD Info from LegacyBios.GetBbsInfo()
31///
32LEGACY_MENU_OPTION LegacyHDMenu = {
33 LEGACY_MENU_OPTION_SIGNATURE,
34 {NULL},
35 0
36};
37
38///
39/// Legacy CD Info from LegacyBios.GetBbsInfo()
40///
41LEGACY_MENU_OPTION LegacyCDMenu = {
42 LEGACY_MENU_OPTION_SIGNATURE,
43 {NULL},
44 0
45};
46
47///
48/// Legacy NET Info from LegacyBios.GetBbsInfo()
49///
50LEGACY_MENU_OPTION LegacyNETMenu = {
51 LEGACY_MENU_OPTION_SIGNATURE,
52 {NULL},
53 0
54};
55
56///
57/// Legacy NET Info from LegacyBios.GetBbsInfo()
58///
59LEGACY_MENU_OPTION LegacyBEVMenu = {
60 LEGACY_MENU_OPTION_SIGNATURE,
61 {NULL},
62 0
63};
64
65
66VOID *mLegacyStartOpCodeHandle = NULL;
67VOID *mLegacyEndOpCodeHandle = NULL;
68EFI_IFR_GUID_LABEL *mLegacyStartLabel = NULL;
69EFI_IFR_GUID_LABEL *mLegacyEndLabel = NULL;
70
71
72HII_VENDOR_DEVICE_PATH mLegacyBootOptionHiiVendorDevicePath = {
73 {
74 {
75 HARDWARE_DEVICE_PATH,
76 HW_VENDOR_DP,
77 {
78 (UINT8) (sizeof (VENDOR_DEVICE_PATH)),
79 (UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8)
80 }
81 },
82 { 0x6bc75598, 0x89b4, 0x483d, { 0x91, 0x60, 0x7f, 0x46, 0x9a, 0x96, 0x35, 0x31 } }
83 },
84 {
85 END_DEVICE_PATH_TYPE,
86 END_ENTIRE_DEVICE_PATH_SUBTYPE,
87 {
88 (UINT8) (END_DEVICE_PATH_LENGTH),
89 (UINT8) ((END_DEVICE_PATH_LENGTH) >> 8)
90 }
91 }
92};
93
94/**
95
96 Build the LegacyFDMenu LegacyHDMenu LegacyCDMenu according to LegacyBios.GetBbsInfo().
97
98**/
99VOID
100GetLegacyOptions (
101 VOID
102 );
103
104
105/**
106
107 Base on the L"LegacyDevOrder" variable to build the current order data.
108
109**/
110VOID
111GetLegacyOptionsOrder (
112 VOID
113 );
114
115/**
116 Re-order the Boot Option according to the DevOrder.
117
118 The routine re-orders the Boot Option in BootOption array according to
119 the order specified by DevOrder.
120
121 @param DevOrder Pointer to buffer containing the BBS Index,
122 high 8-bit value 0xFF indicating a disabled boot option
123 @param DevOrderCount Count of the BBS Index
124 @param EnBootOption Callee allocated buffer containing the enabled Boot Option Numbers
125 @param EnBootOptionCount Count of the enabled Boot Option Numbers
126 @param DisBootOption Callee allocated buffer containing the disabled Boot Option Numbers
127 @param DisBootOptionCount Count of the disabled Boot Option Numbers
128
129 @return EFI_SUCCESS The function completed successfully.
130 @retval other Contain some error, details see the status return by gRT->SetVariable.
131**/
132EFI_STATUS
133OrderLegacyBootOption4SameType (
134 UINT16 *DevOrder,
135 UINTN DevOrderCount,
136 UINT16 **EnBootOption,
137 UINTN *EnBootOptionCount,
138 UINT16 **DisBootOption,
139 UINTN *DisBootOptionCount
140 )
141{
142 EFI_STATUS Status;
143 UINT16 *NewBootOption;
144 UINT16 *BootOrder;
145 UINTN BootOrderSize;
146 UINTN Index;
147 UINTN StartPosition;
148
149 EFI_BOOT_MANAGER_LOAD_OPTION BootOption;
150
151 CHAR16 OptionName[sizeof ("Boot####")];
152 UINT16 *BbsIndexArray;
153 UINT16 *DeviceTypeArray;
154
155 GetEfiGlobalVariable2 (L"BootOrder", (VOID **) &BootOrder, &BootOrderSize);
156 ASSERT (BootOrder != NULL);
157
158 BbsIndexArray = AllocatePool (BootOrderSize);
159 DeviceTypeArray = AllocatePool (BootOrderSize);
160 *EnBootOption = AllocatePool (BootOrderSize);
161 *DisBootOption = AllocatePool (BootOrderSize);
162 *DisBootOptionCount = 0;
163 *EnBootOptionCount = 0;
164 Index = 0;
165 Status = EFI_SUCCESS;
166
167 ASSERT (BbsIndexArray != NULL);
168 ASSERT (DeviceTypeArray != NULL);
169 ASSERT (*EnBootOption != NULL);
170 ASSERT (*DisBootOption != NULL);
171
172 for (Index = 0; Index < BootOrderSize / sizeof (UINT16); Index++) {
173
174 UnicodeSPrint (OptionName, sizeof (OptionName), L"Boot%04x", BootOrder[Index]);
175 Status = EfiBootManagerVariableToLoadOption (OptionName, &BootOption);
176 ASSERT_EFI_ERROR (Status);
177
178 if ((DevicePathType (BootOption.FilePath) == BBS_DEVICE_PATH) &&
179 (DevicePathSubType (BootOption.FilePath) == BBS_BBS_DP)) {
180 //
181 // Legacy Boot Option
182 //
183 ASSERT (BootOption.OptionalDataSize == sizeof (LEGACY_BOOT_OPTION_BBS_DATA));
184
185 DeviceTypeArray[Index] = ((BBS_BBS_DEVICE_PATH *) BootOption.FilePath)->DeviceType;
186 BbsIndexArray [Index] = ((LEGACY_BOOT_OPTION_BBS_DATA *) BootOption.OptionalData)->BbsIndex;
187 } else {
188 DeviceTypeArray[Index] = BBS_TYPE_UNKNOWN;
189 BbsIndexArray [Index] = 0xFFFF;
190 }
191 EfiBootManagerFreeLoadOption (&BootOption);
192 }
193
194 //
195 // Record the corresponding Boot Option Numbers according to the DevOrder
196 // Record the EnBootOption and DisBootOption according to the DevOrder
197 //
198 StartPosition = BootOrderSize / sizeof (UINT16);
199 NewBootOption = AllocatePool (DevOrderCount * sizeof (UINT16));
200 ASSERT (NewBootOption != NULL);
201 while (DevOrderCount-- != 0) {
202 for (Index = 0; Index < BootOrderSize / sizeof (UINT16); Index++) {
203 if (BbsIndexArray[Index] == (DevOrder[DevOrderCount] & 0xFF)) {
204 StartPosition = MIN (StartPosition, Index);
205 NewBootOption[DevOrderCount] = BootOrder[Index];
206
207 if ((DevOrder[DevOrderCount] & 0xFF00) == 0xFF00) {
208 (*DisBootOption)[*DisBootOptionCount] = BootOrder[Index];
209 (*DisBootOptionCount)++;
210 } else {
211 (*EnBootOption)[*EnBootOptionCount] = BootOrder[Index];
212 (*EnBootOptionCount)++;
213 }
214 break;
215 }
216 }
217 }
218
219 //
220 // Overwrite the old BootOption
221 //
222 CopyMem (&BootOrder[StartPosition], NewBootOption, (*DisBootOptionCount + *EnBootOptionCount) * sizeof (UINT16));
223 Status = gRT->SetVariable (
224 L"BootOrder",
225 &gEfiGlobalVariableGuid,
226 VAR_FLAG,
227 BootOrderSize,
228 BootOrder
229 );
230
231 FreePool (NewBootOption);
232 FreePool (DeviceTypeArray);
233 FreePool (BbsIndexArray);
234
235 return Status;
236}
237
238/**
239 Update the legacy BBS boot option. L"LegacyDevOrder" and gEfiLegacyDevOrderVariableGuid EFI Variable
240 is udpated with the new Legacy Boot order. The EFI Variable of "Boot####" and gEfiGlobalVariableGuid
241 is also updated.
242
243 @param NVMapData The data for egacy BBS boot.
244
245 @return EFI_SUCCESS The function completed successfully.
246 @retval EFI_NOT_FOUND If L"LegacyDevOrder" and gEfiLegacyDevOrderVariableGuid EFI Variable can not be found.
247 @retval EFI_OUT_OF_RESOURCES Fail to allocate memory resource
248 @retval other Contain some error, details see the status return by gRT->SetVariable.
249**/
250EFI_STATUS
251UpdateBBSOption (
252 IN LEGACY_BOOT_NV_DATA *NVMapData
253 )
254{
255 UINTN Index;
256 UINTN Index2;
257 UINTN CurrentType;
258 VOID *BootOptionVar;
259 CHAR16 VarName[100];
260 UINTN OptionSize;
261 EFI_STATUS Status;
262 UINT32 *Attribute;
263 LEGACY_MENU_OPTION *OptionMenu;
264 UINT16 *LegacyDev;
265 UINT16 *InitialLegacyDev;
266 UINT8 *VarData;
267 UINTN VarSize;
268 LEGACY_DEV_ORDER_ENTRY *DevOrder;
269 UINT8 *OriginalPtr;
270 UINT8 *DisMap;
271 UINTN Pos;
272 UINTN Bit;
273 UINT16 *NewOrder;
274 UINT16 Tmp;
275 UINT16 *EnBootOption;
276 UINTN EnBootOptionCount;
277 UINT16 *DisBootOption;
278 UINTN DisBootOptionCount;
279 UINTN BufferSize;
280
281
282 DisMap = NULL;
283 NewOrder = NULL;
284 CurrentType = 0;
285 EnBootOption = NULL;
286 DisBootOption = NULL;
287
288
289 DisMap = mLegacyBootOptionPrivate->MaintainMapData->DisableMap;
290 Status = EFI_SUCCESS;
291
292 //
293 // Update the Variable "LegacyDevOrder"
294 //
295 GetVariable2 (VAR_LEGACY_DEV_ORDER, &gEfiLegacyDevOrderVariableGuid, (VOID **) &VarData, &VarSize);
296 if (VarData == NULL) {
297 return EFI_NOT_FOUND;
298 }
299 OriginalPtr = VarData;
300
301 while (mBbsType[CurrentType] != BBS_UNKNOWN) {
302 switch (mBbsType[CurrentType]) {
303 case BBS_FLOPPY:
304 OptionMenu = (LEGACY_MENU_OPTION *) &LegacyFDMenu;
305 LegacyDev = NVMapData->LegacyFD;
306 InitialLegacyDev = mLegacyBootOptionPrivate->MaintainMapData->InitialNvData.LegacyFD;
307 BufferSize = sizeof (NVMapData->LegacyFD);
308 break;
309
310 case BBS_HARDDISK:
311 OptionMenu = (LEGACY_MENU_OPTION *) &LegacyHDMenu;
312 LegacyDev = NVMapData->LegacyHD;
313 InitialLegacyDev = mLegacyBootOptionPrivate->MaintainMapData->InitialNvData.LegacyHD;
314
315 BufferSize = sizeof (NVMapData->LegacyHD);
316 break;
317
318 case BBS_CDROM:
319 OptionMenu = (LEGACY_MENU_OPTION *) &LegacyCDMenu;
320 LegacyDev = NVMapData->LegacyCD;
321 InitialLegacyDev = mLegacyBootOptionPrivate->MaintainMapData->InitialNvData.LegacyCD;
322 BufferSize = sizeof (NVMapData->LegacyCD);
323 break;
324
325 case BBS_EMBED_NETWORK:
326 OptionMenu = (LEGACY_MENU_OPTION *) &LegacyNETMenu;
327 LegacyDev = NVMapData->LegacyNET;
328 InitialLegacyDev = mLegacyBootOptionPrivate->MaintainMapData->InitialNvData.LegacyNET;
329 BufferSize = sizeof (NVMapData->LegacyNET);
330 break;
331
332 default:
333 ASSERT (mBbsType[CurrentType] == BBS_BEV_DEVICE);
334 OptionMenu = (LEGACY_MENU_OPTION *) &LegacyBEVMenu;
335 LegacyDev = NVMapData->LegacyBEV;
336 InitialLegacyDev = mLegacyBootOptionPrivate->MaintainMapData->InitialNvData.LegacyBEV;
337 BufferSize = sizeof (NVMapData->LegacyBEV);
338 break;
339 }
340
341 //
342 // Check whether has value changed.
343 //
344 if (CompareMem (LegacyDev, InitialLegacyDev, BufferSize) == 0) {
345 CurrentType++;
346 continue;
347 }
348
349 DevOrder = (LEGACY_DEV_ORDER_ENTRY *) OriginalPtr;
350 while (VarData < OriginalPtr + VarSize) {
351 if (DevOrder->BbsType == mBbsType[CurrentType]) {
352 break;
353 }
354
355 VarData += sizeof (BBS_TYPE) + DevOrder->Length;
356 DevOrder = (LEGACY_DEV_ORDER_ENTRY *) VarData;
357 }
358
359 if (VarData >= OriginalPtr + VarSize) {
360 FreePool (OriginalPtr);
361 return EFI_NOT_FOUND;
362 }
363
364 NewOrder = AllocateZeroPool (DevOrder->Length - sizeof (DevOrder->Length));
365 if (NewOrder == NULL) {
366 FreePool (OriginalPtr);
367 return EFI_OUT_OF_RESOURCES;
368 }
369
370 for (Index = 0; Index < OptionMenu->MenuNumber; Index++) {
371 if (0xFF == LegacyDev[Index]) {
372 break;
373 }
374
375 NewOrder[Index] = LegacyDev[Index];
376 }
377
378 //
379 // Only the enable/disable state of each boot device with same device type can be changed,
380 // so we can count on the index information in DevOrder.
381 // DisMap bit array is the only reliable source to check a device's en/dis state,
382 // so we use DisMap to set en/dis state of each item in NewOrder array
383 //
384 for (Index2 = 0; Index2 < OptionMenu->MenuNumber; Index2++) {
385 Tmp = (UINT16) (DevOrder->Data[Index2] & 0xFF);
386 Pos = Tmp / 8;
387 Bit = 7 - (Tmp % 8);
388 if ((DisMap[Pos] & (1 << Bit)) != 0) {
389 NewOrder[Index] = (UINT16) (0xFF00 | Tmp);
390 Index++;
391 }
392 }
393
394 CopyMem (
395 DevOrder->Data,
396 NewOrder,
397 DevOrder->Length - sizeof (DevOrder->Length)
398 );
399 FreePool (NewOrder);
400
401 //
402 // Update BootOrder and Boot####.Attribute
403 //
404 // 1. Re-order the Option Number in BootOrder according to Legacy Dev Order
405 //
406 ASSERT (OptionMenu->MenuNumber == DevOrder->Length / sizeof (UINT16) - 1);
407
408 Status = OrderLegacyBootOption4SameType (
409 DevOrder->Data,
410 DevOrder->Length / sizeof (UINT16) - 1,
411 &EnBootOption,
412 &EnBootOptionCount,
413 &DisBootOption,
414 &DisBootOptionCount
415 );
416 if (EFI_ERROR(Status)) {
417 goto Fail;
418 }
419
420 //
421 // 2. Deactivate the DisBootOption and activate the EnBootOption
422 //
423 for (Index = 0; Index < DisBootOptionCount; Index++) {
424 UnicodeSPrint (VarName, sizeof (VarName), L"Boot%04x", DisBootOption[Index]);
425 GetEfiGlobalVariable2 (VarName, (VOID **) &BootOptionVar, &OptionSize);
426 if (BootOptionVar != NULL) {
427 Attribute = (UINT32 *) BootOptionVar;
428 *Attribute &= ~LOAD_OPTION_ACTIVE;
429
430 Status = gRT->SetVariable (
431 VarName,
432 &gEfiGlobalVariableGuid,
433 VAR_FLAG,
434 OptionSize,
435 BootOptionVar
436 );
437
438 FreePool (BootOptionVar);
439 }
440 }
441
442 for (Index = 0; Index < EnBootOptionCount; Index++) {
443 UnicodeSPrint (VarName, sizeof (VarName), L"Boot%04x", EnBootOption[Index]);
444 GetEfiGlobalVariable2 (VarName, (VOID **) &BootOptionVar, &OptionSize);
445 if (BootOptionVar != NULL) {
446 Attribute = (UINT32 *) BootOptionVar;
447 *Attribute |= LOAD_OPTION_ACTIVE;
448
449 Status = gRT->SetVariable (
450 VarName,
451 &gEfiGlobalVariableGuid,
452 VAR_FLAG,
453 OptionSize,
454 BootOptionVar
455 );
456
457 FreePool (BootOptionVar);
458 }
459 }
460
461
462 FreePool (EnBootOption);
463 FreePool (DisBootOption);
464
465 CurrentType++;
466 }
467
468 Status = gRT->SetVariable (
469 VAR_LEGACY_DEV_ORDER,
470 &gEfiLegacyDevOrderVariableGuid,
471 EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE,
472 VarSize,
473 OriginalPtr
474 );
475
476Fail:
477 if (EnBootOption != NULL) {
478 FreePool (EnBootOption);
479 }
480
481 if (DisBootOption != NULL) {
482 FreePool (DisBootOption);
483 }
484
485 FreePool (OriginalPtr);
486 return Status;
487}
488
489/**
490 This function allows a caller to extract the current configuration for one
491 or more named elements from the target driver.
492
493
494 @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
495 @param Request A null-terminated Unicode string in <ConfigRequest> format.
496 @param Progress On return, points to a character in the Request string.
497 Points to the string's null terminator if request was successful.
498 Points to the most recent '&' before the first failing name/value
499 pair (or the beginning of the string if the failure is in the
500 first name/value pair) if the request was not successful.
501 @param Results A null-terminated Unicode string in <ConfigAltResp> format which
502 has all values filled in for the names in the Request string.
503 String to be allocated by the called function.
504
505 @retval EFI_SUCCESS The Results is filled with the requested values.
506 @retval EFI_OUT_OF_RESOURCES Not enough memory to store the results.
507 @retval EFI_INVALID_PARAMETER Request is illegal syntax, or unknown name.
508 @retval EFI_NOT_FOUND Routing data doesn't match any storage in this driver.
509
510**/
511EFI_STATUS
512EFIAPI
513LegacyBootOptionExtractConfig (
514 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
515 IN CONST EFI_STRING Request,
516 OUT EFI_STRING *Progress,
517 OUT EFI_STRING *Results
518 )
519{
520 if (Progress == NULL || Results == NULL) {
521 return EFI_INVALID_PARAMETER;
522 }
523 *Progress = Request;
524 return EFI_NOT_FOUND;
525}
526
527/**
528 This function processes the results of changes in configuration.
529
530
531 @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
532 @param Configuration A null-terminated Unicode string in <ConfigResp> format.
533 @param Progress A pointer to a string filled in with the offset of the most
534 recent '&' before the first failing name/value pair (or the
535 beginning of the string if the failure is in the first
536 name/value pair) or the terminating NULL if all was successful.
537
538 @retval EFI_SUCCESS The Results is processed successfully.
539 @retval EFI_INVALID_PARAMETER Configuration is NULL.
540 @retval EFI_NOT_FOUND Routing data doesn't match any storage in this driver.
541
542**/
543EFI_STATUS
544EFIAPI
545LegacyBootOptionRouteConfig (
546 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
547 IN CONST EFI_STRING Configuration,
548 OUT EFI_STRING *Progress
549 )
550{
551 EFI_STATUS Status;
552 EFI_HII_CONFIG_ROUTING_PROTOCOL *ConfigRouting;
553 LEGACY_BOOT_NV_DATA *CurrentNVMapData;
554 UINTN BufferSize;
555
556
557 if (Configuration == NULL || Progress == NULL) {
558 return EFI_INVALID_PARAMETER;
559 }
560
561 *Progress = Configuration;
562
563 //
564 // Check routing data in <ConfigHdr>.
565 // Note: there is no name for Name/Value storage, only GUID will be checked
566 //
567 if (!HiiIsConfigHdrMatch (Configuration, &mLegacyBootOptionGuid, mLegacyBootStorageName)) {
568 return EFI_NOT_FOUND;
569 }
570
571 Status = gBS->LocateProtocol (
572 &gEfiHiiConfigRoutingProtocolGuid,
573 NULL,
574 (VOID **) &ConfigRouting
575 );
576 if (EFI_ERROR (Status)) {
577 return Status;
578 }
579
580 //
581 // Convert <ConfigResp> to buffer data by helper function ConfigToBlock()
582 //
583 CurrentNVMapData = &mLegacyBootOptionPrivate->MaintainMapData->CurrentNvData;
584 Status = ConfigRouting->ConfigToBlock (
585 ConfigRouting,
586 Configuration,
587 (UINT8 *) CurrentNVMapData,
588 &BufferSize,
589 Progress
590 );
591 ASSERT_EFI_ERROR (Status);
592
593 Status = UpdateBBSOption (CurrentNVMapData);
594
595 return Status;
596}
597
598/**
599 Refresh the global UpdateData structure.
600
601**/
602VOID
603RefreshLegacyUpdateData (
604 VOID
605 )
606{
607 //
608 // Free current updated date
609 //
610 if (mLegacyStartOpCodeHandle != NULL) {
611 HiiFreeOpCodeHandle (mLegacyStartOpCodeHandle);
612 }
613 if (mLegacyEndOpCodeHandle != NULL) {
614 HiiFreeOpCodeHandle (mLegacyEndOpCodeHandle);
615 }
616
617 //
618 // Create new OpCode Handle
619 //
620 mLegacyStartOpCodeHandle = HiiAllocateOpCodeHandle ();
621 mLegacyEndOpCodeHandle = HiiAllocateOpCodeHandle ();
622
623 //
624 // Create Hii Extend Label OpCode as the start opcode
625 //
626 mLegacyStartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
627 mLegacyStartOpCodeHandle,
628 &gEfiIfrTianoGuid,
629 NULL,
630 sizeof (EFI_IFR_GUID_LABEL)
631 );
632 mLegacyStartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
633
634 mLegacyStartLabel->Number = FORM_BOOT_LEGACY_DEVICE_ID;
635
636 //
637 // Create Hii Extend Label OpCode as the start opcode
638 //
639 mLegacyEndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
640 mLegacyEndOpCodeHandle,
641 &gEfiIfrTianoGuid,
642 NULL,
643 sizeof (EFI_IFR_GUID_LABEL)
644 );
645 mLegacyEndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
646
647 mLegacyEndLabel->Number = FORM_BOOT_LEGACY_LABEL_END;
648
649}
650
651/**
652 Get the Menu Entry from the list in Menu Entry List.
653
654 If MenuNumber is great or equal to the number of Menu
655 Entry in the list, then ASSERT.
656
657 @param MenuOption The Menu Entry List to read the menu entry.
658 @param MenuNumber The index of Menu Entry.
659
660 @return The Menu Entry.
661
662**/
663LEGACY_MENU_ENTRY *
664GetMenuEntry (
665 LEGACY_MENU_OPTION *MenuOption,
666 UINTN MenuNumber
667 )
668{
669 LEGACY_MENU_ENTRY *NewMenuEntry;
670 UINTN Index;
671 LIST_ENTRY *List;
672
673 ASSERT (MenuNumber < MenuOption->MenuNumber);
674
675 List = MenuOption->Head.ForwardLink;
676 for (Index = 0; Index < MenuNumber; Index++) {
677 List = List->ForwardLink;
678 }
679
680 NewMenuEntry = CR (List, LEGACY_MENU_ENTRY, Link, LEGACY_MENU_ENTRY_SIGNATURE);
681
682 return NewMenuEntry;
683}
684
685/**
686 Create string tokens for a menu from its help strings and display strings
687
688 @param HiiHandle Hii Handle of the package to be updated.
689 @param MenuOption The Menu whose string tokens need to be created
690
691**/
692VOID
693CreateLegacyMenuStringToken (
694 IN EFI_HII_HANDLE HiiHandle,
695 IN LEGACY_MENU_OPTION *MenuOption
696 )
697{
698 LEGACY_MENU_ENTRY *NewMenuEntry;
699 UINTN Index;
700
701 for (Index = 0; Index < MenuOption->MenuNumber; Index++) {
702 NewMenuEntry = GetMenuEntry (MenuOption, Index);
703
704 NewMenuEntry->DisplayStringToken = HiiSetString (
705 HiiHandle,
706 0,
707 NewMenuEntry->DisplayString,
708 NULL
709 );
710
711 if (NULL == NewMenuEntry->HelpString) {
712 NewMenuEntry->HelpStringToken = NewMenuEntry->DisplayStringToken;
713 } else {
714 NewMenuEntry->HelpStringToken = HiiSetString (
715 HiiHandle,
716 0,
717 NewMenuEntry->HelpString,
718 NULL
719 );
720 }
721 }
722}
723
724/**
725 Create a dynamic page so that Legacy Device boot order
726 can be set for specified device type.
727
728 @param UpdatePageId The form ID. It also spefies the legacy device type.
729
730
731**/
732VOID
733UpdateLegacyDeviceOrderPage (
734 IN UINT16 UpdatePageId
735 )
736{
737 LEGACY_MENU_OPTION *OptionMenu;
738 LEGACY_MENU_ENTRY *NewMenuEntry;
739 EFI_STRING_ID StrRef;
740 EFI_STRING_ID StrRefHelp;
741 UINT16 *Default;
742 UINT16 Index;
743 UINT16 Key;
744 CHAR16 String[100];
745 CHAR16 *TypeStr;
746 CHAR16 *TypeStrHelp;
747 CHAR16 *FormTitle;
748 VOID *OptionsOpCodeHandle;
749 VOID *DefaultOpCodeHandle;
750
751 Key = 0;
752 StrRef = 0;
753 StrRefHelp = 0;
754 OptionMenu = NULL;
755 TypeStr = NULL;
756 TypeStrHelp = NULL;
757 Default = NULL;
758
759 RefreshLegacyUpdateData();
760
761 //
762 // Create oneof option list
763 //
764 switch (UpdatePageId) {
765 case FORM_FLOPPY_BOOT_ID:
766 OptionMenu = (LEGACY_MENU_OPTION *) &LegacyFDMenu;
767 Key = (UINT16) LEGACY_FD_QUESTION_ID;
768 TypeStr = STR_FLOPPY;
769 TypeStrHelp = STR_FLOPPY_HELP;
770 FormTitle = STR_FLOPPY_TITLE;
771 Default = mLegacyBootOptionPrivate->MaintainMapData->CurrentNvData.LegacyFD;
772 break;
773
774 case FORM_HARDDISK_BOOT_ID:
775 OptionMenu = (LEGACY_MENU_OPTION *) &LegacyHDMenu;
776 Key = (UINT16) LEGACY_HD_QUESTION_ID;
777 TypeStr = STR_HARDDISK;
778 TypeStrHelp = STR_HARDDISK_HELP;
779 FormTitle = STR_HARDDISK_TITLE;
780 Default = mLegacyBootOptionPrivate->MaintainMapData->CurrentNvData.LegacyHD;
781 break;
782
783 case FORM_CDROM_BOOT_ID:
784 OptionMenu = (LEGACY_MENU_OPTION *) &LegacyCDMenu;
785 Key = (UINT16) LEGACY_CD_QUESTION_ID;
786 TypeStr = STR_CDROM;
787 TypeStrHelp = STR_CDROM_HELP;
788 FormTitle = STR_CDROM_TITLE;
789 Default = mLegacyBootOptionPrivate->MaintainMapData->CurrentNvData.LegacyCD;
790 break;
791
792 case FORM_NET_BOOT_ID:
793 OptionMenu = (LEGACY_MENU_OPTION *) &LegacyNETMenu;
794 Key = (UINT16) LEGACY_NET_QUESTION_ID;
795 TypeStr = STR_NET;
796 TypeStrHelp = STR_NET_HELP;
797 FormTitle = STR_NET_TITLE;
798 Default = mLegacyBootOptionPrivate->MaintainMapData->CurrentNvData.LegacyNET;
799 break;
800
801 case FORM_BEV_BOOT_ID:
802 OptionMenu = (LEGACY_MENU_OPTION *) &LegacyBEVMenu;
803 Key = (UINT16) LEGACY_BEV_QUESTION_ID;
804 TypeStr = STR_BEV;
805 TypeStrHelp = STR_BEV_HELP;
806 FormTitle = STR_BEV_TITLE;
807 Default = mLegacyBootOptionPrivate->MaintainMapData->CurrentNvData.LegacyBEV;
808 break;
809
810 default:
811 DEBUG ((EFI_D_ERROR, "Invalid command ID for updating page!\n"));
812 return;
813 }
814
815 HiiSetString (mLegacyBootOptionPrivate->HiiHandle, STRING_TOKEN(STR_ORDER_CHANGE_PROMPT), FormTitle, NULL);
816
817 CreateLegacyMenuStringToken (mLegacyBootOptionPrivate->HiiHandle, OptionMenu);
818
819 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
820 ASSERT (OptionsOpCodeHandle != NULL);
821
822
823 for (Index = 0; Index < OptionMenu->MenuNumber; Index++) {
824 NewMenuEntry = GetMenuEntry (OptionMenu, Index);
825 //
826 // Create OneOf for each legacy device
827 //
828 HiiCreateOneOfOptionOpCode (
829 OptionsOpCodeHandle,
830 NewMenuEntry->DisplayStringToken,
831 0,
832 EFI_IFR_TYPE_NUM_SIZE_16,
833 ((LEGACY_DEVICE_CONTEXT *) NewMenuEntry->VariableContext)->BbsIndex
834 );
835 }
836
837 //
838 // Create OneOf for item "Disabled"
839 //
840 HiiCreateOneOfOptionOpCode (
841 OptionsOpCodeHandle,
842 STRING_TOKEN (STR_DISABLE_LEGACY_DEVICE),
843 0,
844 EFI_IFR_TYPE_NUM_SIZE_16,
845 0xFF
846 );
847
848 //
849 // Create oneof tag here for FD/HD/CD #1 #2
850 //
851 for (Index = 0; Index < OptionMenu->MenuNumber; Index++) {
852 DefaultOpCodeHandle = HiiAllocateOpCodeHandle ();
853 ASSERT (DefaultOpCodeHandle != NULL);
854
855 HiiCreateDefaultOpCode (
856 DefaultOpCodeHandle,
857 EFI_HII_DEFAULT_CLASS_STANDARD,
858 EFI_IFR_TYPE_NUM_SIZE_16,
859 *Default++
860 );
861
862 //
863 // Create the string for oneof tag
864 //
865 UnicodeSPrint (String, sizeof (String), TypeStr, Index);
866 StrRef = HiiSetString (mLegacyBootOptionPrivate->HiiHandle, 0, String, NULL);
867
868 UnicodeSPrint (String, sizeof (String), TypeStrHelp, Index);
869 StrRefHelp = HiiSetString (mLegacyBootOptionPrivate->HiiHandle, 0, String, NULL);
870
871 HiiCreateOneOfOpCode (
872 mLegacyStartOpCodeHandle,
873 (EFI_QUESTION_ID) (Key + Index),
874 VARSTORE_ID_LEGACY_BOOT,
875 (UINT16) (Key + Index * 2 - CONFIG_OPTION_OFFSET),
876 StrRef,
877 StrRefHelp,
878 EFI_IFR_FLAG_CALLBACK,
879 EFI_IFR_NUMERIC_SIZE_2,
880 OptionsOpCodeHandle,
881 DefaultOpCodeHandle //NULL //
882 );
883
884 HiiFreeOpCodeHandle (DefaultOpCodeHandle);
885 }
886
887 HiiUpdateForm (
888 mLegacyBootOptionPrivate->HiiHandle,
889 &mLegacyBootOptionGuid,
890 LEGACY_ORDER_CHANGE_FORM_ID,
891 mLegacyStartOpCodeHandle,
892 mLegacyEndOpCodeHandle
893 );
894
895 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
896}
897
898
899/**
900 Adjust question value when one question value has been changed.
901
902 @param QuestionId The question id for the value changed question.
903 @param Value The value for the changed question.
904
905**/
906VOID
907AdjustOptionValue (
908 IN UINT16 QuestionId,
909 IN EFI_IFR_TYPE_VALUE *Value
910 )
911{
912 UINTN Number;
913 UINT16 *Default;
914 LEGACY_BOOT_NV_DATA *CurrentNVMap;
915 UINT16 *CurrentVal;
916 UINTN Index;
917 UINTN Index2;
918 UINTN Index3;
919 UINTN NewValuePos;
920 UINTN OldValue;
921 UINTN NewValue;
922 UINT8 *DisMap;
923 UINTN Pos;
924 UINTN Bit;
925
926 Number = 0;
927 CurrentVal = 0;
928 Default = NULL;
929 NewValue = 0;
930 NewValuePos = 0;
931 OldValue = 0;
932
933 //
934 // Update Select FD/HD/CD/NET/BEV Order Form
935 //
936 ASSERT ((QuestionId >= LEGACY_FD_QUESTION_ID) && (QuestionId < LEGACY_BEV_QUESTION_ID + MAX_MENU_NUMBER));
937
938 CurrentNVMap = &mLegacyBootOptionPrivate->MaintainMapData->CurrentNvData;
939 HiiGetBrowserData (&mLegacyBootOptionGuid, mLegacyBootStorageName, sizeof (LEGACY_BOOT_NV_DATA), (UINT8 *) CurrentNVMap);
940 DisMap = mLegacyBootOptionPrivate->MaintainMapData->DisableMap;
941
942 if (QuestionId >= LEGACY_FD_QUESTION_ID && QuestionId < LEGACY_FD_QUESTION_ID + MAX_MENU_NUMBER) {
943 Number = (UINT16) LegacyFDMenu.MenuNumber;
944 CurrentVal = CurrentNVMap->LegacyFD;
945 Default = mLegacyBootOptionPrivate->MaintainMapData->LastTimeNvData.LegacyFD;
946 } else if (QuestionId >= LEGACY_HD_QUESTION_ID && QuestionId < LEGACY_HD_QUESTION_ID + MAX_MENU_NUMBER) {
947 Number = (UINT16) LegacyHDMenu.MenuNumber;
948 CurrentVal = CurrentNVMap->LegacyHD;
949 Default = mLegacyBootOptionPrivate->MaintainMapData->LastTimeNvData.LegacyHD;
950 } else if (QuestionId >= LEGACY_CD_QUESTION_ID && QuestionId < LEGACY_CD_QUESTION_ID + MAX_MENU_NUMBER) {
951 Number = (UINT16) LegacyCDMenu.MenuNumber;
952 CurrentVal = CurrentNVMap->LegacyCD;
953 Default = mLegacyBootOptionPrivate->MaintainMapData->LastTimeNvData.LegacyCD;
954 } else if (QuestionId >= LEGACY_NET_QUESTION_ID && QuestionId < LEGACY_NET_QUESTION_ID + MAX_MENU_NUMBER) {
955 Number = (UINT16) LegacyNETMenu.MenuNumber;
956 CurrentVal = CurrentNVMap->LegacyNET;
957 Default = mLegacyBootOptionPrivate->MaintainMapData->LastTimeNvData.LegacyNET;
958 } else if (QuestionId >= LEGACY_BEV_QUESTION_ID && QuestionId < LEGACY_BEV_QUESTION_ID + MAX_MENU_NUMBER) {
959 Number = (UINT16) LegacyBEVMenu.MenuNumber;
960 CurrentVal = CurrentNVMap->LegacyBEV;
961 Default = mLegacyBootOptionPrivate->MaintainMapData->LastTimeNvData.LegacyBEV;
962 }
963
964 //
965 // First, find the different position
966 // if there is change, it should be only one
967 //
968 for (Index = 0; Index < Number; Index++) {
969 if (CurrentVal[Index] != Default[Index]) {
970 OldValue = Default[Index];
971 NewValue = CurrentVal[Index];
972 break;
973 }
974 }
975
976 if (Index != Number) {
977 //
978 // there is change, now process
979 //
980 if (0xFF == NewValue) {
981 //
982 // This item will be disable
983 // Just move the items behind this forward to overlap it
984 //
985 Pos = OldValue / 8;
986 Bit = 7 - (OldValue % 8);
987 DisMap[Pos] = (UINT8) (DisMap[Pos] | (UINT8) (1 << Bit));
988 for (Index2 = Index; Index2 < Number - 1; Index2++) {
989 CurrentVal[Index2] = CurrentVal[Index2 + 1];
990 }
991
992 CurrentVal[Index2] = 0xFF;
993 } else {
994 for (Index2 = 0; Index2 < Number; Index2++) {
995 if (Index2 == Index) {
996 continue;
997 }
998
999 if (Default[Index2] == NewValue) {
1000 //
1001 // If NewValue is in OldLegacyDev array
1002 // remember its old position
1003 //
1004 NewValuePos = Index2;
1005 break;
1006 }
1007 }
1008
1009 if (Index2 != Number) {
1010 //
1011 // We will change current item to an existing item
1012 // (It's hard to describe here, please read code, it's like a cycle-moving)
1013 //
1014 for (Index2 = NewValuePos; Index2 != Index;) {
1015 if (NewValuePos < Index) {
1016 CurrentVal[Index2] = Default[Index2 + 1];
1017 Index2++;
1018 } else {
1019 CurrentVal[Index2] = Default[Index2 - 1];
1020 Index2--;
1021 }
1022 }
1023 } else {
1024 //
1025 // If NewValue is not in OldlegacyDev array, we are changing to a disabled item
1026 // so we should modify DisMap to reflect the change
1027 //
1028 Pos = NewValue / 8;
1029 Bit = 7 - (NewValue % 8);
1030 DisMap[Pos] = (UINT8) (DisMap[Pos] & (~ (UINT8) (1 << Bit)));
1031 if (0xFF != OldValue) {
1032 //
1033 // Because NewValue is a item that was disabled before
1034 // so after changing the OldValue should be disabled
1035 // actually we are doing a swap of enable-disable states of two items
1036 //
1037 Pos = OldValue / 8;
1038 Bit = 7 - (OldValue % 8);
1039 DisMap[Pos] = (UINT8) (DisMap[Pos] | (UINT8) (1 << Bit));
1040 }
1041 }
1042 }
1043 //
1044 // To prevent DISABLE appears in the middle of the list
1045 // we should perform a re-ordering
1046 //
1047 Index3 = Index;
1048 Index = 0;
1049 while (Index < Number) {
1050 if (0xFF != CurrentVal[Index]) {
1051 Index++;
1052 continue;
1053 }
1054
1055 Index2 = Index;
1056 Index2++;
1057 while (Index2 < Number) {
1058 if (0xFF != CurrentVal[Index2]) {
1059 break;
1060 }
1061
1062 Index2++;
1063 }
1064
1065 if (Index2 < Number) {
1066 CurrentVal[Index] = CurrentVal[Index2];
1067 CurrentVal[Index2] = 0xFF;
1068 }
1069
1070 Index++;
1071 }
1072
1073 //
1074 // Return correct question value.
1075 //
1076 Value->u16 = CurrentVal[Index3];
1077 CopyMem (Default, CurrentVal, sizeof (UINT16) * Number);
1078 }
1079
1080 //
1081 // Pass changed uncommitted data back to Form Browser
1082 //
1083 HiiSetBrowserData (&mLegacyBootOptionGuid, mLegacyBootStorageName, sizeof (LEGACY_BOOT_NV_DATA), (UINT8 *) CurrentNVMap, NULL);
1084}
1085
1086/**
1087 This call back function is registered with Boot Manager formset.
1088 When user selects a boot option, this call back function will
1089 be triggered. The boot option is saved for later processing.
1090
1091
1092 @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
1093 @param Action Specifies the type of action taken by the browser.
1094 @param QuestionId A unique value which is sent to the original exporting driver
1095 so that it can identify the type of data to expect.
1096 @param Type The type of value for the question.
1097 @param Value A pointer to the data being sent to the original exporting driver.
1098 @param ActionRequest On return, points to the action requested by the callback function.
1099
1100 @retval EFI_SUCCESS The callback successfully handled the action.
1101 @retval EFI_INVALID_PARAMETER The setup browser call this function with invalid parameters.
1102
1103**/
1104EFI_STATUS
1105EFIAPI
1106LegacyBootOptionCallback (
1107 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
1108 IN EFI_BROWSER_ACTION Action,
1109 IN EFI_QUESTION_ID QuestionId,
1110 IN UINT8 Type,
1111 IN EFI_IFR_TYPE_VALUE *Value,
1112 OUT EFI_BROWSER_ACTION_REQUEST *ActionRequest
1113 )
1114{
1115 if (Action != EFI_BROWSER_ACTION_CHANGED && Action != EFI_BROWSER_ACTION_CHANGING && Action != EFI_BROWSER_ACTION_FORM_OPEN) {
1116 //
1117 // Do nothing for other UEFI Action. Only do call back when data is changed or the form is open.
1118 //
1119 return EFI_UNSUPPORTED;
1120 }
1121
1122 if ((Value == NULL) || (ActionRequest == NULL)) {
1123 return EFI_INVALID_PARAMETER;
1124 }
1125
1126 if (Action == EFI_BROWSER_ACTION_FORM_OPEN) {
1127 if (QuestionId == FORM_FLOPPY_BOOT_ID) {
1128 if (!mFirstEnterLegacyForm) {
1129 //
1130 // The leagcyBootMaintUiLib depends on the LegacyBootManagerLib to realize its functionality.
1131 // We need to do the leagcy boot options related actions after the LegacyBootManagerLib has been initialized.
1132 // Opening the legacy menus is the appropriate time that the LegacyBootManagerLib has already been initialized.
1133 //
1134 mFirstEnterLegacyForm = TRUE;
1135 GetLegacyOptions ();
1136 GetLegacyOptionsOrder ();
1137 }
1138 }
1139 }
1140
1141 if (Action == EFI_BROWSER_ACTION_CHANGING) {
1142 switch (QuestionId) {
1143 case FORM_FLOPPY_BOOT_ID:
1144 case FORM_HARDDISK_BOOT_ID:
1145 case FORM_CDROM_BOOT_ID:
1146 case FORM_NET_BOOT_ID:
1147 case FORM_BEV_BOOT_ID:
1148 UpdateLegacyDeviceOrderPage (QuestionId);
1149 break;
1150
1151 default:
1152 break;
1153 }
1154 } else if (Action == EFI_BROWSER_ACTION_CHANGED) {
1155 if ((Value == NULL) || (ActionRequest == NULL)) {
1156 return EFI_INVALID_PARAMETER;
1157 }
1158
1159 if ((QuestionId >= LEGACY_FD_QUESTION_ID) && (QuestionId < LEGACY_BEV_QUESTION_ID + MAX_MENU_NUMBER)) {
1160 AdjustOptionValue(QuestionId, Value);
1161 }
1162 }
1163 return EFI_SUCCESS;
1164}
1165
1166
1167/**
1168 Create a menu entry by given menu type.
1169
1170 @param MenuType The Menu type to be created.
1171
1172 @retval NULL If failed to create the menu.
1173 @return the new menu entry.
1174
1175**/
1176LEGACY_MENU_ENTRY *
1177CreateMenuEntry (
1178 VOID
1179 )
1180{
1181 LEGACY_MENU_ENTRY *MenuEntry;
1182
1183 //
1184 // Create new menu entry
1185 //
1186 MenuEntry = AllocateZeroPool (sizeof (LEGACY_MENU_ENTRY));
1187 if (MenuEntry == NULL) {
1188 return NULL;
1189 }
1190
1191 MenuEntry->VariableContext = AllocateZeroPool (sizeof (LEGACY_DEVICE_CONTEXT));
1192 if (MenuEntry->VariableContext == NULL) {
1193 FreePool (MenuEntry);
1194 return NULL;
1195 }
1196
1197 MenuEntry->Signature = LEGACY_MENU_ENTRY_SIGNATURE;
1198 return MenuEntry;
1199}
1200
1201/**
1202
1203 Base on the L"LegacyDevOrder" variable to build the current order data.
1204
1205**/
1206VOID
1207GetLegacyOptionsOrder (
1208 VOID
1209 )
1210{
1211 UINTN VarSize;
1212 UINT8 *VarData;
1213 UINT8 *VarTmp;
1214 LEGACY_DEV_ORDER_ENTRY *DevOrder;
1215 UINT16 *LegacyDev;
1216 UINTN Index;
1217 LEGACY_MENU_OPTION *OptionMenu;
1218 UINT16 VarDevOrder;
1219 UINTN Pos;
1220 UINTN Bit;
1221 UINT8 *DisMap;
1222 UINTN TotalLength;
1223
1224 LegacyDev = NULL;
1225 OptionMenu = NULL;
1226
1227 DisMap = ZeroMem (mLegacyBootOptionPrivate->MaintainMapData->DisableMap, sizeof (mLegacyBootOptionPrivate->MaintainMapData->DisableMap));
1228
1229 //
1230 // Get Device Order from variable
1231 //
1232 GetVariable2 (VAR_LEGACY_DEV_ORDER, &gEfiLegacyDevOrderVariableGuid, (VOID **) &VarData, &VarSize);
1233 VarTmp = VarData;
1234 if (NULL != VarData) {
1235 DevOrder = (LEGACY_DEV_ORDER_ENTRY *) VarData;
1236 while (VarData < VarTmp + VarSize) {
1237 switch (DevOrder->BbsType) {
1238 case BBS_FLOPPY:
1239 LegacyDev = mLegacyBootOptionPrivate->MaintainMapData->InitialNvData.LegacyFD;
1240 OptionMenu = &LegacyFDMenu;
1241 break;
1242
1243 case BBS_HARDDISK:
1244 LegacyDev = mLegacyBootOptionPrivate->MaintainMapData->InitialNvData.LegacyHD;
1245 OptionMenu = &LegacyHDMenu;
1246 break;
1247
1248 case BBS_CDROM:
1249 LegacyDev = mLegacyBootOptionPrivate->MaintainMapData->InitialNvData.LegacyCD;
1250 OptionMenu = &LegacyCDMenu;
1251 break;
1252
1253 case BBS_EMBED_NETWORK:
1254 LegacyDev = mLegacyBootOptionPrivate->MaintainMapData->InitialNvData.LegacyNET;
1255 OptionMenu = &LegacyNETMenu;
1256 break;
1257
1258 case BBS_BEV_DEVICE:
1259 LegacyDev = mLegacyBootOptionPrivate->MaintainMapData->InitialNvData.LegacyBEV;
1260 OptionMenu = &LegacyBEVMenu;
1261 break;
1262
1263 case BBS_UNKNOWN:
1264 default:
1265 ASSERT (FALSE);
1266 DEBUG ((DEBUG_ERROR, "Unsupported device type found!\n"));
1267 break;
1268 }
1269
1270 //
1271 // Create oneof tag here for FD/HD/CD #1 #2
1272 //
1273 for (Index = 0; Index < OptionMenu->MenuNumber; Index++) {
1274 TotalLength = sizeof (BBS_TYPE) + sizeof (UINT16) + Index * sizeof (UINT16);
1275 VarDevOrder = *(UINT16 *) ((UINT8 *) DevOrder + TotalLength);
1276
1277 if (0xFF00 == (VarDevOrder & 0xFF00)) {
1278 LegacyDev[Index] = 0xFF;
1279 Pos = (VarDevOrder & 0xFF) / 8;
1280 Bit = 7 - ((VarDevOrder & 0xFF) % 8);
1281 DisMap[Pos] = (UINT8) (DisMap[Pos] | (UINT8) (1 << Bit));
1282 } else {
1283 LegacyDev[Index] = VarDevOrder & 0xFF;
1284 }
1285 }
1286
1287 VarData ++;
1288 VarData += *(UINT16 *) VarData;
1289 DevOrder = (LEGACY_DEV_ORDER_ENTRY *) VarData;
1290 }
1291 }
1292
1293 CopyMem (&mLegacyBootOptionPrivate->MaintainMapData->LastTimeNvData, &mLegacyBootOptionPrivate->MaintainMapData->InitialNvData, sizeof (LEGACY_BOOT_NV_DATA));
1294 CopyMem (&mLegacyBootOptionPrivate->MaintainMapData->CurrentNvData, &mLegacyBootOptionPrivate->MaintainMapData->InitialNvData, sizeof (LEGACY_BOOT_NV_DATA));
1295}
1296
1297/**
1298
1299 Build the LegacyFDMenu LegacyHDMenu LegacyCDMenu according to LegacyBios.GetBbsInfo().
1300
1301**/
1302VOID
1303GetLegacyOptions (
1304 VOID
1305 )
1306{
1307 LEGACY_MENU_ENTRY *NewMenuEntry;
1308 LEGACY_DEVICE_CONTEXT *NewLegacyDevContext;
1309 EFI_BOOT_MANAGER_LOAD_OPTION *BootOption;
1310 UINTN BootOptionCount;
1311 UINT16 Index;
1312 UINTN FDNum;
1313 UINTN HDNum;
1314 UINTN CDNum;
1315 UINTN NETNum;
1316 UINTN BEVNum;
1317
1318 //
1319 // Initialize Bbs Table Context from BBS info data
1320 //
1321 InitializeListHead (&LegacyFDMenu.Head);
1322 InitializeListHead (&LegacyHDMenu.Head);
1323 InitializeListHead (&LegacyCDMenu.Head);
1324 InitializeListHead (&LegacyNETMenu.Head);
1325 InitializeListHead (&LegacyBEVMenu.Head);
1326
1327 FDNum = 0;
1328 HDNum = 0;
1329 CDNum = 0;
1330 NETNum = 0;
1331 BEVNum = 0;
1332
1333 EfiBootManagerConnectAll ();
1334
1335 //
1336 // for better user experience
1337 // 1. User changes HD configuration (e.g.: unplug HDD), here we have a chance to remove the HDD boot option
1338 // 2. User enables/disables UEFI PXE, here we have a chance to add/remove EFI Network boot option
1339 //
1340 EfiBootManagerRefreshAllBootOption ();
1341
1342 BootOption = EfiBootManagerGetLoadOptions (&BootOptionCount, LoadOptionTypeBoot);
1343 for (Index = 0; Index < BootOptionCount; Index++) {
1344 if ((DevicePathType (BootOption[Index].FilePath) != BBS_DEVICE_PATH) ||
1345 (DevicePathSubType (BootOption[Index].FilePath) != BBS_BBS_DP)
1346 ) {
1347 continue;
1348 }
1349 ASSERT (BootOption[Index].OptionalDataSize == sizeof (LEGACY_BOOT_OPTION_BBS_DATA));
1350 NewMenuEntry = CreateMenuEntry ();
1351 ASSERT (NewMenuEntry != NULL);
1352
1353 NewLegacyDevContext = (LEGACY_DEVICE_CONTEXT *) NewMenuEntry->VariableContext;
1354 NewLegacyDevContext->BbsIndex = ((LEGACY_BOOT_OPTION_BBS_DATA *) BootOption[Index].OptionalData)->BbsIndex;
1355 NewLegacyDevContext->Description = AllocateCopyPool (StrSize (BootOption[Index].Description), BootOption[Index].Description);
1356 ASSERT (NewLegacyDevContext->Description != NULL);
1357
1358 NewMenuEntry->DisplayString = NewLegacyDevContext->Description;
1359 NewMenuEntry->HelpString = NULL;
1360
1361 switch (((BBS_BBS_DEVICE_PATH *) BootOption[Index].FilePath)->DeviceType) {
1362 case BBS_TYPE_FLOPPY:
1363 InsertTailList (&LegacyFDMenu.Head, &NewMenuEntry->Link);
1364 FDNum++;
1365 break;
1366
1367 case BBS_TYPE_HARDDRIVE:
1368 InsertTailList (&LegacyHDMenu.Head, &NewMenuEntry->Link);
1369 HDNum++;
1370 break;
1371
1372 case BBS_TYPE_CDROM:
1373 InsertTailList (&LegacyCDMenu.Head, &NewMenuEntry->Link);
1374 CDNum++;
1375 break;
1376
1377 case BBS_TYPE_EMBEDDED_NETWORK:
1378 InsertTailList (&LegacyNETMenu.Head, &NewMenuEntry->Link);
1379 NETNum++;
1380 break;
1381
1382 case BBS_TYPE_BEV:
1383 InsertTailList (&LegacyBEVMenu.Head, &NewMenuEntry->Link);
1384 BEVNum++;
1385 break;
1386 }
1387 }
1388
1389 EfiBootManagerFreeLoadOptions (BootOption, BootOptionCount);
1390
1391 LegacyFDMenu.MenuNumber = FDNum;
1392 LegacyHDMenu.MenuNumber = HDNum;
1393 LegacyCDMenu.MenuNumber = CDNum;
1394 LegacyNETMenu.MenuNumber = NETNum;
1395 LegacyBEVMenu.MenuNumber = BEVNum;
1396}
1397
1398
1399/**
1400
1401 Install Boot Manager Menu driver.
1402
1403 @param ImageHandle The image handle.
1404 @param SystemTable The system table.
1405
1406 @retval EFI_SUCEESS Install Boot manager menu success.
1407 @retval Other Return error status.
1408
1409**/
1410EFI_STATUS
1411EFIAPI
1412LegacyBootMaintUiLibConstructor (
1413 IN EFI_HANDLE ImageHandle,
1414 IN EFI_SYSTEM_TABLE *SystemTable
1415 )
1416{
1417 EFI_STATUS Status;
1418 EFI_LEGACY_BIOS_PROTOCOL *LegacyBios;
1419 LEGACY_BOOT_OPTION_CALLBACK_DATA *LegacyBootOptionData;
1420
1421 Status = gBS->LocateProtocol (&gEfiLegacyBiosProtocolGuid, NULL, (VOID **) &LegacyBios);
1422 if (!EFI_ERROR (Status)) {
1423 //
1424 // Create LegacyBootOptionData structures for Driver Callback
1425 //
1426 LegacyBootOptionData = AllocateZeroPool (sizeof (LEGACY_BOOT_OPTION_CALLBACK_DATA));
1427 ASSERT (LegacyBootOptionData != NULL);
1428
1429 LegacyBootOptionData->MaintainMapData = AllocateZeroPool (sizeof (LEGACY_BOOT_MAINTAIN_DATA));
1430 ASSERT (LegacyBootOptionData->MaintainMapData != NULL);
1431
1432 LegacyBootOptionData->ConfigAccess.ExtractConfig = LegacyBootOptionExtractConfig;
1433 LegacyBootOptionData->ConfigAccess.RouteConfig = LegacyBootOptionRouteConfig;
1434 LegacyBootOptionData->ConfigAccess.Callback = LegacyBootOptionCallback;
1435
1436 //
1437 // Install Device Path Protocol and Config Access protocol to driver handle
1438 //
1439 Status = gBS->InstallMultipleProtocolInterfaces (
1440 &LegacyBootOptionData->DriverHandle,
1441 &gEfiDevicePathProtocolGuid,
1442 &mLegacyBootOptionHiiVendorDevicePath,
1443 &gEfiHiiConfigAccessProtocolGuid,
1444 &LegacyBootOptionData->ConfigAccess,
1445 NULL
1446 );
1447 ASSERT_EFI_ERROR (Status);
1448
1449 //
1450 // Publish our HII data
1451 //
1452 LegacyBootOptionData->HiiHandle = HiiAddPackages (
1453 &mLegacyBootOptionGuid,
1454 LegacyBootOptionData->DriverHandle,
1455 LegacyBootMaintUiVfrBin,
1456 LegacyBootMaintUiLibStrings,
1457 NULL
1458 );
1459 ASSERT (LegacyBootOptionData->HiiHandle != NULL);
1460
1461 mLegacyBootOptionPrivate = LegacyBootOptionData;
1462 }
1463
1464 return EFI_SUCCESS;
1465}
1466
1467/**
1468 Destructor of Customized Display Library Instance.
1469
1470 @param ImageHandle The firmware allocated handle for the EFI image.
1471 @param SystemTable A pointer to the EFI System Table.
1472
1473 @retval EFI_SUCCESS The destructor completed successfully.
1474 @retval Other value The destructor did not complete successfully.
1475
1476**/
1477EFI_STATUS
1478EFIAPI
1479LegacyBootMaintUiLibDestructor (
1480 IN EFI_HANDLE ImageHandle,
1481 IN EFI_SYSTEM_TABLE *SystemTable
1482 )
1483{
1484 EFI_STATUS Status;
1485
1486 if (mLegacyBootOptionPrivate != NULL && mLegacyBootOptionPrivate->DriverHandle != NULL) {
1487 Status = gBS->UninstallMultipleProtocolInterfaces (
1488 mLegacyBootOptionPrivate->DriverHandle,
1489 &gEfiDevicePathProtocolGuid,
1490 &mLegacyBootOptionHiiVendorDevicePath,
1491 &gEfiHiiConfigAccessProtocolGuid,
1492 &mLegacyBootOptionPrivate->ConfigAccess,
1493 NULL
1494 );
1495 ASSERT_EFI_ERROR (Status);
1496
1497 HiiRemovePackages (mLegacyBootOptionPrivate->HiiHandle);
1498
1499 FreePool (mLegacyBootOptionPrivate->MaintainMapData);
1500 FreePool (mLegacyBootOptionPrivate);
1501 }
1502
1503 return EFI_SUCCESS;
1504}
1505
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette