2 Legacy Boot Maintainence UI implementation.
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
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.
16 #include "LegacyBootMaintUi.h"
18 LEGACY_BOOT_OPTION_CALLBACK_DATA
*mLegacyBootOptionPrivate
;
19 EFI_GUID mLegacyBootOptionGuid
= LEGACY_BOOT_OPTION_FORMSET_GUID
;
20 CHAR16 mLegacyBootStorageName
[] = L
"LegacyBootData";
21 BBS_TYPE mBbsType
[] = {BBS_FLOPPY
, BBS_HARDDISK
, BBS_CDROM
, BBS_EMBED_NETWORK
, BBS_BEV_DEVICE
, BBS_UNKNOWN
};
25 /// Legacy FD Info from LegacyBios.GetBbsInfo()
27 LEGACY_MENU_OPTION LegacyFDMenu
= {
28 LEGACY_MENU_OPTION_SIGNATURE
,
34 /// Legacy HD Info from LegacyBios.GetBbsInfo()
36 LEGACY_MENU_OPTION LegacyHDMenu
= {
37 LEGACY_MENU_OPTION_SIGNATURE
,
43 /// Legacy CD Info from LegacyBios.GetBbsInfo()
45 LEGACY_MENU_OPTION LegacyCDMenu
= {
46 LEGACY_MENU_OPTION_SIGNATURE
,
52 /// Legacy NET Info from LegacyBios.GetBbsInfo()
54 LEGACY_MENU_OPTION LegacyNETMenu
= {
55 LEGACY_MENU_OPTION_SIGNATURE
,
61 /// Legacy NET Info from LegacyBios.GetBbsInfo()
63 LEGACY_MENU_OPTION LegacyBEVMenu
= {
64 LEGACY_MENU_OPTION_SIGNATURE
,
70 VOID
*mLegacyStartOpCodeHandle
= NULL
;
71 VOID
*mLegacyEndOpCodeHandle
= NULL
;
72 EFI_IFR_GUID_LABEL
*mLegacyStartLabel
= NULL
;
73 EFI_IFR_GUID_LABEL
*mLegacyEndLabel
= NULL
;
76 HII_VENDOR_DEVICE_PATH mLegacyBootOptionHiiVendorDevicePath
= {
82 (UINT8
) (sizeof (VENDOR_DEVICE_PATH
)),
83 (UINT8
) ((sizeof (VENDOR_DEVICE_PATH
)) >> 8)
86 { 0x6bc75598, 0x89b4, 0x483d, { 0x91, 0x60, 0x7f, 0x46, 0x9a, 0x96, 0x35, 0x31 } }
90 END_ENTIRE_DEVICE_PATH_SUBTYPE
,
92 (UINT8
) (END_DEVICE_PATH_LENGTH
),
93 (UINT8
) ((END_DEVICE_PATH_LENGTH
) >> 8)
100 Re-order the Boot Option according to the DevOrder.
102 The routine re-orders the Boot Option in BootOption array according to
103 the order specified by DevOrder.
105 @param DevOrder Pointer to buffer containing the BBS Index,
106 high 8-bit value 0xFF indicating a disabled boot option
107 @param DevOrderCount Count of the BBS Index
108 @param EnBootOption Callee allocated buffer containing the enabled Boot Option Numbers
109 @param EnBootOptionCount Count of the enabled Boot Option Numbers
110 @param DisBootOption Callee allocated buffer containing the disabled Boot Option Numbers
111 @param DisBootOptionCount Count of the disabled Boot Option Numbers
114 OrderLegacyBootOption4SameType (
117 UINT16
**EnBootOption
,
118 UINTN
*EnBootOptionCount
,
119 UINT16
**DisBootOption
,
120 UINTN
*DisBootOptionCount
124 UINT16
*NewBootOption
;
130 EFI_BOOT_MANAGER_LOAD_OPTION BootOption
;
132 CHAR16 OptionName
[sizeof ("Boot####")];
133 UINT16
*BbsIndexArray
;
134 UINT16
*DeviceTypeArray
;
136 GetEfiGlobalVariable2 (L
"BootOrder", (VOID
**) &BootOrder
, &BootOrderSize
);
137 ASSERT (BootOrder
!= NULL
);
139 BbsIndexArray
= AllocatePool (BootOrderSize
);
140 DeviceTypeArray
= AllocatePool (BootOrderSize
);
141 *EnBootOption
= AllocatePool (BootOrderSize
);
142 *DisBootOption
= AllocatePool (BootOrderSize
);
143 *DisBootOptionCount
= 0;
144 *EnBootOptionCount
= 0;
147 ASSERT (BbsIndexArray
!= NULL
);
148 ASSERT (DeviceTypeArray
!= NULL
);
149 ASSERT (*EnBootOption
!= NULL
);
150 ASSERT (*DisBootOption
!= NULL
);
152 for (Index
= 0; Index
< BootOrderSize
/ sizeof (UINT16
); Index
++) {
154 UnicodeSPrint (OptionName
, sizeof (OptionName
), L
"Boot%04x", BootOrder
[Index
]);
155 Status
= EfiBootManagerVariableToLoadOption (OptionName
, &BootOption
);
156 ASSERT_EFI_ERROR (Status
);
158 if ((DevicePathType (BootOption
.FilePath
) == BBS_DEVICE_PATH
) &&
159 (DevicePathSubType (BootOption
.FilePath
) == BBS_BBS_DP
)) {
161 // Legacy Boot Option
163 ASSERT (BootOption
.OptionalDataSize
== sizeof (LEGACY_BOOT_OPTION_BBS_DATA
));
165 DeviceTypeArray
[Index
] = ((BBS_BBS_DEVICE_PATH
*) BootOption
.FilePath
)->DeviceType
;
166 BbsIndexArray
[Index
] = ((LEGACY_BOOT_OPTION_BBS_DATA
*) BootOption
.OptionalData
)->BbsIndex
;
168 DeviceTypeArray
[Index
] = BBS_TYPE_UNKNOWN
;
169 BbsIndexArray
[Index
] = 0xFFFF;
171 EfiBootManagerFreeLoadOption (&BootOption
);
175 // Record the corresponding Boot Option Numbers according to the DevOrder
176 // Record the EnBootOption and DisBootOption according to the DevOrder
178 StartPosition
= BootOrderSize
/ sizeof (UINT16
);
179 NewBootOption
= AllocatePool (DevOrderCount
* sizeof (UINT16
));
180 ASSERT (NewBootOption
!= NULL
);
181 while (DevOrderCount
-- != 0) {
182 for (Index
= 0; Index
< BootOrderSize
/ sizeof (UINT16
); Index
++) {
183 if (BbsIndexArray
[Index
] == (DevOrder
[DevOrderCount
] & 0xFF)) {
184 StartPosition
= MIN (StartPosition
, Index
);
185 NewBootOption
[DevOrderCount
] = BootOrder
[Index
];
187 if ((DevOrder
[DevOrderCount
] & 0xFF00) == 0xFF00) {
188 (*DisBootOption
)[*DisBootOptionCount
] = BootOrder
[Index
];
189 (*DisBootOptionCount
)++;
191 (*EnBootOption
)[*EnBootOptionCount
] = BootOrder
[Index
];
192 (*EnBootOptionCount
)++;
200 // Overwrite the old BootOption
202 CopyMem (&BootOrder
[StartPosition
], NewBootOption
, (*DisBootOptionCount
+ *EnBootOptionCount
) * sizeof (UINT16
));
203 Status
= gRT
->SetVariable (
205 &gEfiGlobalVariableGuid
,
210 ASSERT_EFI_ERROR (Status
);
212 FreePool (NewBootOption
);
213 FreePool (DeviceTypeArray
);
214 FreePool (BbsIndexArray
);
218 Update the legacy BBS boot option. L"LegacyDevOrder" and gEfiLegacyDevOrderVariableGuid EFI Variable
219 is udpated with the new Legacy Boot order. The EFI Variable of "Boot####" and gEfiGlobalVariableGuid
222 @param NVMapData The data for egacy BBS boot.
224 @return EFI_SUCCESS The function completed successfully.
225 @retval EFI_NOT_FOUND If L"LegacyDevOrder" and gEfiLegacyDevOrderVariableGuid EFI Variable can be found.
226 @retval EFI_OUT_OF_RESOURCES Fail to allocate memory resource
230 IN LEGACY_BOOT_NV_DATA
*NVMapData
241 LEGACY_MENU_OPTION
*OptionMenu
;
243 UINT16
*InitialLegacyDev
;
246 LEGACY_DEV_ORDER_ENTRY
*DevOrder
;
253 UINT16
*EnBootOption
;
254 UINTN EnBootOptionCount
;
255 UINT16
*DisBootOption
;
256 UINTN DisBootOptionCount
;
265 DisMap
= mLegacyBootOptionPrivate
->MaintainMapData
->DisableMap
;
266 Status
= EFI_SUCCESS
;
269 // Update the Variable "LegacyDevOrder"
271 GetVariable2 (VAR_LEGACY_DEV_ORDER
, &gEfiLegacyDevOrderVariableGuid
, (VOID
**) &VarData
, &VarSize
);
272 if (VarData
== NULL
) {
273 return EFI_NOT_FOUND
;
275 OriginalPtr
= VarData
;
277 while (mBbsType
[CurrentType
] != BBS_UNKNOWN
) {
278 switch (mBbsType
[CurrentType
]) {
280 OptionMenu
= (LEGACY_MENU_OPTION
*) &LegacyFDMenu
;
281 LegacyDev
= NVMapData
->LegacyFD
;
282 InitialLegacyDev
= mLegacyBootOptionPrivate
->MaintainMapData
->InitialNvData
.LegacyFD
;
283 BufferSize
= sizeof (NVMapData
->LegacyFD
);
287 OptionMenu
= (LEGACY_MENU_OPTION
*) &LegacyHDMenu
;
288 LegacyDev
= NVMapData
->LegacyHD
;
289 InitialLegacyDev
= mLegacyBootOptionPrivate
->MaintainMapData
->InitialNvData
.LegacyHD
;
291 BufferSize
= sizeof (NVMapData
->LegacyHD
);
295 OptionMenu
= (LEGACY_MENU_OPTION
*) &LegacyCDMenu
;
296 LegacyDev
= NVMapData
->LegacyCD
;
297 InitialLegacyDev
= mLegacyBootOptionPrivate
->MaintainMapData
->InitialNvData
.LegacyCD
;
298 BufferSize
= sizeof (NVMapData
->LegacyCD
);
301 case BBS_EMBED_NETWORK
:
302 OptionMenu
= (LEGACY_MENU_OPTION
*) &LegacyNETMenu
;
303 LegacyDev
= NVMapData
->LegacyNET
;
304 InitialLegacyDev
= mLegacyBootOptionPrivate
->MaintainMapData
->InitialNvData
.LegacyNET
;
305 BufferSize
= sizeof (NVMapData
->LegacyNET
);
309 ASSERT (mBbsType
[CurrentType
] == BBS_BEV_DEVICE
);
310 OptionMenu
= (LEGACY_MENU_OPTION
*) &LegacyBEVMenu
;
311 LegacyDev
= NVMapData
->LegacyBEV
;
312 InitialLegacyDev
= mLegacyBootOptionPrivate
->MaintainMapData
->InitialNvData
.LegacyBEV
;
313 BufferSize
= sizeof (NVMapData
->LegacyBEV
);
318 // Check whether has value changed.
320 if (CompareMem (LegacyDev
, InitialLegacyDev
, BufferSize
) == 0) {
325 DevOrder
= (LEGACY_DEV_ORDER_ENTRY
*) OriginalPtr
;
326 while (VarData
< OriginalPtr
+ VarSize
) {
327 if (DevOrder
->BbsType
== mBbsType
[CurrentType
]) {
331 VarData
+= sizeof (BBS_TYPE
) + DevOrder
->Length
;
332 DevOrder
= (LEGACY_DEV_ORDER_ENTRY
*) VarData
;
335 if (VarData
>= OriginalPtr
+ VarSize
) {
336 FreePool (OriginalPtr
);
337 return EFI_NOT_FOUND
;
340 NewOrder
= AllocateZeroPool (DevOrder
->Length
- sizeof (DevOrder
->Length
));
341 if (NewOrder
== NULL
) {
342 FreePool (OriginalPtr
);
343 return EFI_OUT_OF_RESOURCES
;
346 for (Index
= 0; Index
< OptionMenu
->MenuNumber
; Index
++) {
347 if (0xFF == LegacyDev
[Index
]) {
351 NewOrder
[Index
] = LegacyDev
[Index
];
355 // Only the enable/disable state of each boot device with same device type can be changed,
356 // so we can count on the index information in DevOrder.
357 // DisMap bit array is the only reliable source to check a device's en/dis state,
358 // so we use DisMap to set en/dis state of each item in NewOrder array
360 for (Index2
= 0; Index2
< OptionMenu
->MenuNumber
; Index2
++) {
361 Tmp
= (UINT16
) (DevOrder
->Data
[Index2
] & 0xFF);
364 if ((DisMap
[Pos
] & (1 << Bit
)) != 0) {
365 NewOrder
[Index
] = (UINT16
) (0xFF00 | Tmp
);
373 DevOrder
->Length
- sizeof (DevOrder
->Length
)
378 // Update BootOrder and Boot####.Attribute
380 // 1. Re-order the Option Number in BootOrder according to Legacy Dev Order
382 ASSERT (OptionMenu
->MenuNumber
== DevOrder
->Length
/ sizeof (UINT16
) - 1);
384 OrderLegacyBootOption4SameType (
386 DevOrder
->Length
/ sizeof (UINT16
) - 1,
394 // 2. Deactivate the DisBootOption and activate the EnBootOption
396 for (Index
= 0; Index
< DisBootOptionCount
; Index
++) {
397 UnicodeSPrint (VarName
, sizeof (VarName
), L
"Boot%04x", DisBootOption
[Index
]);
398 GetEfiGlobalVariable2 (VarName
, (VOID
**) &BootOptionVar
, &OptionSize
);
399 if (BootOptionVar
!= NULL
) {
400 Attribute
= (UINT32
*) BootOptionVar
;
401 *Attribute
&= ~LOAD_OPTION_ACTIVE
;
403 Status
= gRT
->SetVariable (
405 &gEfiGlobalVariableGuid
,
411 FreePool (BootOptionVar
);
415 for (Index
= 0; Index
< EnBootOptionCount
; Index
++) {
416 UnicodeSPrint (VarName
, sizeof (VarName
), L
"Boot%04x", EnBootOption
[Index
]);
417 GetEfiGlobalVariable2 (VarName
, (VOID
**) &BootOptionVar
, &OptionSize
);
418 if (BootOptionVar
!= NULL
) {
419 Attribute
= (UINT32
*) BootOptionVar
;
420 *Attribute
|= LOAD_OPTION_ACTIVE
;
422 Status
= gRT
->SetVariable (
424 &gEfiGlobalVariableGuid
,
430 FreePool (BootOptionVar
);
435 FreePool (EnBootOption
);
436 FreePool (DisBootOption
);
441 Status
= gRT
->SetVariable (
442 VAR_LEGACY_DEV_ORDER
,
443 &gEfiLegacyDevOrderVariableGuid
,
444 EFI_VARIABLE_BOOTSERVICE_ACCESS
| EFI_VARIABLE_NON_VOLATILE
,
449 FreePool (OriginalPtr
);
454 This function allows a caller to extract the current configuration for one
455 or more named elements from the target driver.
458 @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
459 @param Request A null-terminated Unicode string in <ConfigRequest> format.
460 @param Progress On return, points to a character in the Request string.
461 Points to the string's null terminator if request was successful.
462 Points to the most recent '&' before the first failing name/value
463 pair (or the beginning of the string if the failure is in the
464 first name/value pair) if the request was not successful.
465 @param Results A null-terminated Unicode string in <ConfigAltResp> format which
466 has all values filled in for the names in the Request string.
467 String to be allocated by the called function.
469 @retval EFI_SUCCESS The Results is filled with the requested values.
470 @retval EFI_OUT_OF_RESOURCES Not enough memory to store the results.
471 @retval EFI_INVALID_PARAMETER Request is illegal syntax, or unknown name.
472 @retval EFI_NOT_FOUND Routing data doesn't match any storage in this driver.
477 LegacyBootOptionExtractConfig (
478 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL
*This
,
479 IN CONST EFI_STRING Request
,
480 OUT EFI_STRING
*Progress
,
481 OUT EFI_STRING
*Results
484 if (Progress
== NULL
|| Results
== NULL
) {
485 return EFI_INVALID_PARAMETER
;
488 return EFI_NOT_FOUND
;
492 This function processes the results of changes in configuration.
495 @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
496 @param Configuration A null-terminated Unicode string in <ConfigResp> format.
497 @param Progress A pointer to a string filled in with the offset of the most
498 recent '&' before the first failing name/value pair (or the
499 beginning of the string if the failure is in the first
500 name/value pair) or the terminating NULL if all was successful.
502 @retval EFI_SUCCESS The Results is processed successfully.
503 @retval EFI_INVALID_PARAMETER Configuration is NULL.
504 @retval EFI_NOT_FOUND Routing data doesn't match any storage in this driver.
509 LegacyBootOptionRouteConfig (
510 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL
*This
,
511 IN CONST EFI_STRING Configuration
,
512 OUT EFI_STRING
*Progress
516 EFI_HII_CONFIG_ROUTING_PROTOCOL
*ConfigRouting
;
517 LEGACY_BOOT_NV_DATA
*CurrentNVMapData
;
521 if (Configuration
== NULL
|| Progress
== NULL
) {
522 return EFI_INVALID_PARAMETER
;
526 // Check routing data in <ConfigHdr>.
527 // Note: there is no name for Name/Value storage, only GUID will be checked
529 if (!HiiIsConfigHdrMatch (Configuration
, &mLegacyBootOptionGuid
, mLegacyBootStorageName
)) {
530 return EFI_NOT_FOUND
;
533 Status
= gBS
->LocateProtocol (
534 &gEfiHiiConfigRoutingProtocolGuid
,
536 (VOID
**) &ConfigRouting
538 if (EFI_ERROR (Status
)) {
543 // Convert <ConfigResp> to buffer data by helper function ConfigToBlock()
545 CurrentNVMapData
= &mLegacyBootOptionPrivate
->MaintainMapData
->CurrentNvData
;
546 Status
= ConfigRouting
->ConfigToBlock (
549 (UINT8
*) CurrentNVMapData
,
553 ASSERT_EFI_ERROR (Status
);
555 Status
= UpdateBBSOption (CurrentNVMapData
);
561 Refresh the global UpdateData structure.
565 RefreshLegacyUpdateData (
570 // Free current updated date
572 if (mLegacyStartOpCodeHandle
!= NULL
) {
573 HiiFreeOpCodeHandle (mLegacyStartOpCodeHandle
);
575 if (mLegacyEndOpCodeHandle
!= NULL
) {
576 HiiFreeOpCodeHandle (mLegacyEndOpCodeHandle
);
580 // Create new OpCode Handle
582 mLegacyStartOpCodeHandle
= HiiAllocateOpCodeHandle ();
583 mLegacyEndOpCodeHandle
= HiiAllocateOpCodeHandle ();
586 // Create Hii Extend Label OpCode as the start opcode
588 mLegacyStartLabel
= (EFI_IFR_GUID_LABEL
*) HiiCreateGuidOpCode (
589 mLegacyStartOpCodeHandle
,
592 sizeof (EFI_IFR_GUID_LABEL
)
594 mLegacyStartLabel
->ExtendOpCode
= EFI_IFR_EXTEND_OP_LABEL
;
596 mLegacyStartLabel
->Number
= FORM_BOOT_LEGACY_DEVICE_ID
;
599 // Create Hii Extend Label OpCode as the start opcode
601 mLegacyEndLabel
= (EFI_IFR_GUID_LABEL
*) HiiCreateGuidOpCode (
602 mLegacyEndOpCodeHandle
,
605 sizeof (EFI_IFR_GUID_LABEL
)
607 mLegacyEndLabel
->ExtendOpCode
= EFI_IFR_EXTEND_OP_LABEL
;
609 mLegacyEndLabel
->Number
= FORM_BOOT_LEGACY_LABEL_END
;
614 Get the Menu Entry from the list in Menu Entry List.
616 If MenuNumber is great or equal to the number of Menu
617 Entry in the list, then ASSERT.
619 @param MenuOption The Menu Entry List to read the menu entry.
620 @param MenuNumber The index of Menu Entry.
622 @return The Menu Entry.
627 LEGACY_MENU_OPTION
*MenuOption
,
631 LEGACY_MENU_ENTRY
*NewMenuEntry
;
635 ASSERT (MenuNumber
< MenuOption
->MenuNumber
);
637 List
= MenuOption
->Head
.ForwardLink
;
638 for (Index
= 0; Index
< MenuNumber
; Index
++) {
639 List
= List
->ForwardLink
;
642 NewMenuEntry
= CR (List
, LEGACY_MENU_ENTRY
, Link
, LEGACY_MENU_ENTRY_SIGNATURE
);
648 Create string tokens for a menu from its help strings and display strings
650 @param HiiHandle Hii Handle of the package to be updated.
651 @param MenuOption The Menu whose string tokens need to be created
655 CreateLegacyMenuStringToken (
656 IN EFI_HII_HANDLE HiiHandle
,
657 IN LEGACY_MENU_OPTION
*MenuOption
660 LEGACY_MENU_ENTRY
*NewMenuEntry
;
663 for (Index
= 0; Index
< MenuOption
->MenuNumber
; Index
++) {
664 NewMenuEntry
= GetMenuEntry (MenuOption
, Index
);
666 NewMenuEntry
->DisplayStringToken
= HiiSetString (
669 NewMenuEntry
->DisplayString
,
673 if (NULL
== NewMenuEntry
->HelpString
) {
674 NewMenuEntry
->HelpStringToken
= NewMenuEntry
->DisplayStringToken
;
676 NewMenuEntry
->HelpStringToken
= HiiSetString (
679 NewMenuEntry
->HelpString
,
687 Create a dynamic page so that Legacy Device boot order
688 can be set for specified device type.
690 @param UpdatePageId The form ID. It also spefies the legacy device type.
695 UpdateLegacyDeviceOrderPage (
696 IN UINT16 UpdatePageId
699 LEGACY_MENU_OPTION
*OptionMenu
;
700 LEGACY_MENU_ENTRY
*NewMenuEntry
;
701 EFI_STRING_ID StrRef
;
702 EFI_STRING_ID StrRefHelp
;
711 VOID
*OptionsOpCodeHandle
;
712 VOID
*DefaultOpCodeHandle
;
721 BbsType
= BBS_FLOPPY
;
723 RefreshLegacyUpdateData();
726 // Create oneof option list
728 switch (UpdatePageId
) {
729 case FORM_FLOPPY_BOOT_ID
:
730 OptionMenu
= (LEGACY_MENU_OPTION
*) &LegacyFDMenu
;
731 Key
= (UINT16
) LEGACY_FD_QUESTION_ID
;
732 TypeStr
= STR_FLOPPY
;
733 TypeStrHelp
= STR_FLOPPY_HELP
;
734 FormTitle
= STR_FLOPPY_TITLE
;
735 BbsType
= BBS_FLOPPY
;
736 Default
= mLegacyBootOptionPrivate
->MaintainMapData
->CurrentNvData
.LegacyFD
;
739 case FORM_HARDDISK_BOOT_ID
:
740 OptionMenu
= (LEGACY_MENU_OPTION
*) &LegacyHDMenu
;
741 Key
= (UINT16
) LEGACY_HD_QUESTION_ID
;
742 TypeStr
= STR_HARDDISK
;
743 TypeStrHelp
= STR_HARDDISK_HELP
;
744 FormTitle
= STR_HARDDISK_TITLE
;
745 BbsType
= BBS_HARDDISK
;
746 Default
= mLegacyBootOptionPrivate
->MaintainMapData
->CurrentNvData
.LegacyHD
;
749 case FORM_CDROM_BOOT_ID
:
750 OptionMenu
= (LEGACY_MENU_OPTION
*) &LegacyCDMenu
;
751 Key
= (UINT16
) LEGACY_CD_QUESTION_ID
;
753 TypeStrHelp
= STR_CDROM_HELP
;
754 FormTitle
= STR_CDROM_TITLE
;
756 Default
= mLegacyBootOptionPrivate
->MaintainMapData
->CurrentNvData
.LegacyCD
;
759 case FORM_NET_BOOT_ID
:
760 OptionMenu
= (LEGACY_MENU_OPTION
*) &LegacyNETMenu
;
761 Key
= (UINT16
) LEGACY_NET_QUESTION_ID
;
763 TypeStrHelp
= STR_NET_HELP
;
764 FormTitle
= STR_NET_TITLE
;
765 BbsType
= BBS_EMBED_NETWORK
;
766 Default
= mLegacyBootOptionPrivate
->MaintainMapData
->CurrentNvData
.LegacyNET
;
769 case FORM_BEV_BOOT_ID
:
770 OptionMenu
= (LEGACY_MENU_OPTION
*) &LegacyBEVMenu
;
771 Key
= (UINT16
) LEGACY_BEV_QUESTION_ID
;
773 TypeStrHelp
= STR_BEV_HELP
;
774 FormTitle
= STR_BEV_TITLE
;
775 BbsType
= BBS_BEV_DEVICE
;
776 Default
= mLegacyBootOptionPrivate
->MaintainMapData
->CurrentNvData
.LegacyBEV
;
780 DEBUG ((EFI_D_ERROR
, "Invalid command ID for updating page!\n"));
784 HiiSetString (mLegacyBootOptionPrivate
->HiiHandle
, STRING_TOKEN(STR_ORDER_CHANGE_PROMPT
), FormTitle
, NULL
);
786 CreateLegacyMenuStringToken (mLegacyBootOptionPrivate
->HiiHandle
, OptionMenu
);
788 OptionsOpCodeHandle
= HiiAllocateOpCodeHandle ();
789 ASSERT (OptionsOpCodeHandle
!= NULL
);
792 for (Index
= 0; Index
< OptionMenu
->MenuNumber
; Index
++) {
793 NewMenuEntry
= GetMenuEntry (OptionMenu
, Index
);
795 // Create OneOf for each legacy device
797 HiiCreateOneOfOptionOpCode (
799 NewMenuEntry
->DisplayStringToken
,
801 EFI_IFR_TYPE_NUM_SIZE_16
,
802 ((LEGACY_DEVICE_CONTEXT
*) NewMenuEntry
->VariableContext
)->BbsIndex
807 // Create OneOf for item "Disabled"
809 HiiCreateOneOfOptionOpCode (
811 STRING_TOKEN (STR_DISABLE_LEGACY_DEVICE
),
813 EFI_IFR_TYPE_NUM_SIZE_16
,
818 // Create oneof tag here for FD/HD/CD #1 #2
820 for (Index
= 0; Index
< OptionMenu
->MenuNumber
; Index
++) {
821 DefaultOpCodeHandle
= HiiAllocateOpCodeHandle ();
822 ASSERT (DefaultOpCodeHandle
!= NULL
);
824 HiiCreateDefaultOpCode (
826 EFI_HII_DEFAULT_CLASS_STANDARD
,
827 EFI_IFR_TYPE_NUM_SIZE_16
,
832 // Create the string for oneof tag
834 UnicodeSPrint (String
, sizeof (String
), TypeStr
, Index
);
835 StrRef
= HiiSetString (mLegacyBootOptionPrivate
->HiiHandle
, 0, String
, NULL
);
837 UnicodeSPrint (String
, sizeof (String
), TypeStrHelp
, Index
);
838 StrRefHelp
= HiiSetString (mLegacyBootOptionPrivate
->HiiHandle
, 0, String
, NULL
);
840 HiiCreateOneOfOpCode (
841 mLegacyStartOpCodeHandle
,
842 (EFI_QUESTION_ID
) (Key
+ Index
),
843 VARSTORE_ID_LEGACY_BOOT
,
844 (UINT16
) (Key
+ Index
* 2 - CONFIG_OPTION_OFFSET
),
847 EFI_IFR_FLAG_CALLBACK
,
848 EFI_IFR_NUMERIC_SIZE_2
,
850 DefaultOpCodeHandle
//NULL //
853 HiiFreeOpCodeHandle (DefaultOpCodeHandle
);
857 mLegacyBootOptionPrivate
->HiiHandle
,
858 &mLegacyBootOptionGuid
,
859 LEGACY_ORDER_CHANGE_FORM_ID
,
860 mLegacyStartOpCodeHandle
,
861 mLegacyEndOpCodeHandle
864 HiiFreeOpCodeHandle (OptionsOpCodeHandle
);
869 Adjust question value when one question value has been changed.
871 @param QuestionId The question id for the value changed question.
872 @param Value The value for the changed question.
877 IN UINT16 QuestionId
,
878 IN EFI_IFR_TYPE_VALUE
*Value
883 LEGACY_DEV_ORDER_ENTRY
*DevOrder
;
885 LEGACY_BOOT_NV_DATA
*CurrentNVMap
;
898 BbsType
= BBS_UNKNOWN
;
907 // Update Select FD/HD/CD/NET/BEV Order Form
909 ASSERT ((QuestionId
>= LEGACY_FD_QUESTION_ID
) && (QuestionId
< LEGACY_BEV_QUESTION_ID
+ MAX_MENU_NUMBER
));
911 CurrentNVMap
= &mLegacyBootOptionPrivate
->MaintainMapData
->CurrentNvData
;
912 HiiGetBrowserData (&mLegacyBootOptionGuid
, mLegacyBootStorageName
, sizeof (LEGACY_BOOT_NV_DATA
), (UINT8
*) CurrentNVMap
);
913 DisMap
= mLegacyBootOptionPrivate
->MaintainMapData
->DisableMap
;
915 if (QuestionId
>= LEGACY_FD_QUESTION_ID
&& QuestionId
< LEGACY_FD_QUESTION_ID
+ MAX_MENU_NUMBER
) {
916 Number
= (UINT16
) LegacyFDMenu
.MenuNumber
;
917 BbsType
= BBS_FLOPPY
;
918 CurrentVal
= CurrentNVMap
->LegacyFD
;
919 Default
= mLegacyBootOptionPrivate
->MaintainMapData
->LastTimeNvData
.LegacyFD
;
920 } else if (QuestionId
>= LEGACY_HD_QUESTION_ID
&& QuestionId
< LEGACY_HD_QUESTION_ID
+ MAX_MENU_NUMBER
) {
921 Number
= (UINT16
) LegacyHDMenu
.MenuNumber
;
922 BbsType
= BBS_HARDDISK
;
923 CurrentVal
= CurrentNVMap
->LegacyHD
;
924 Default
= mLegacyBootOptionPrivate
->MaintainMapData
->LastTimeNvData
.LegacyHD
;
925 } else if (QuestionId
>= LEGACY_CD_QUESTION_ID
&& QuestionId
< LEGACY_CD_QUESTION_ID
+ MAX_MENU_NUMBER
) {
926 Number
= (UINT16
) LegacyCDMenu
.MenuNumber
;
928 CurrentVal
= CurrentNVMap
->LegacyCD
;
929 Default
= mLegacyBootOptionPrivate
->MaintainMapData
->LastTimeNvData
.LegacyCD
;
930 } else if (QuestionId
>= LEGACY_NET_QUESTION_ID
&& QuestionId
< LEGACY_NET_QUESTION_ID
+ MAX_MENU_NUMBER
) {
931 Number
= (UINT16
) LegacyNETMenu
.MenuNumber
;
932 BbsType
= BBS_EMBED_NETWORK
;
933 CurrentVal
= CurrentNVMap
->LegacyNET
;
934 Default
= mLegacyBootOptionPrivate
->MaintainMapData
->LastTimeNvData
.LegacyNET
;
935 } else if (QuestionId
>= LEGACY_BEV_QUESTION_ID
&& QuestionId
< LEGACY_BEV_QUESTION_ID
+ MAX_MENU_NUMBER
) {
936 Number
= (UINT16
) LegacyBEVMenu
.MenuNumber
;
937 BbsType
= BBS_BEV_DEVICE
;
938 CurrentVal
= CurrentNVMap
->LegacyBEV
;
939 Default
= mLegacyBootOptionPrivate
->MaintainMapData
->LastTimeNvData
.LegacyBEV
;
943 // First, find the different position
944 // if there is change, it should be only one
946 for (Index
= 0; Index
< Number
; Index
++) {
947 if (CurrentVal
[Index
] != Default
[Index
]) {
948 OldValue
= Default
[Index
];
949 NewValue
= CurrentVal
[Index
];
954 if (Index
!= Number
) {
956 // there is change, now process
958 if (0xFF == NewValue
) {
960 // This item will be disable
961 // Just move the items behind this forward to overlap it
964 Bit
= 7 - (OldValue
% 8);
965 DisMap
[Pos
] = (UINT8
) (DisMap
[Pos
] | (UINT8
) (1 << Bit
));
966 for (Index2
= Index
; Index2
< Number
- 1; Index2
++) {
967 CurrentVal
[Index2
] = CurrentVal
[Index2
+ 1];
970 CurrentVal
[Index2
] = 0xFF;
972 for (Index2
= 0; Index2
< Number
; Index2
++) {
973 if (Index2
== Index
) {
977 if (Default
[Index2
] == NewValue
) {
979 // If NewValue is in OldLegacyDev array
980 // remember its old position
982 NewValuePos
= Index2
;
987 if (Index2
!= Number
) {
989 // We will change current item to an existing item
990 // (It's hard to describe here, please read code, it's like a cycle-moving)
992 for (Index2
= NewValuePos
; Index2
!= Index
;) {
993 if (NewValuePos
< Index
) {
994 CurrentVal
[Index2
] = Default
[Index2
+ 1];
997 CurrentVal
[Index2
] = Default
[Index2
- 1];
1003 // If NewValue is not in OldlegacyDev array, we are changing to a disabled item
1004 // so we should modify DisMap to reflect the change
1007 Bit
= 7 - (NewValue
% 8);
1008 DisMap
[Pos
] = (UINT8
) (DisMap
[Pos
] & (~ (UINT8
) (1 << Bit
)));
1009 if (0xFF != OldValue
) {
1011 // Because NewValue is a item that was disabled before
1012 // so after changing the OldValue should be disabled
1013 // actually we are doing a swap of enable-disable states of two items
1016 Bit
= 7 - (OldValue
% 8);
1017 DisMap
[Pos
] = (UINT8
) (DisMap
[Pos
] | (UINT8
) (1 << Bit
));
1022 // To prevent DISABLE appears in the middle of the list
1023 // we should perform a re-ordering
1027 while (Index
< Number
) {
1028 if (0xFF != CurrentVal
[Index
]) {
1035 while (Index2
< Number
) {
1036 if (0xFF != CurrentVal
[Index2
]) {
1043 if (Index2
< Number
) {
1044 CurrentVal
[Index
] = CurrentVal
[Index2
];
1045 CurrentVal
[Index2
] = 0xFF;
1052 // Return correct question value.
1054 Value
->u16
= CurrentVal
[Index3
];
1055 CopyMem (Default
, CurrentVal
, sizeof (UINT16
) * Number
);
1059 // Pass changed uncommitted data back to Form Browser
1061 HiiSetBrowserData (&mLegacyBootOptionGuid
, mLegacyBootStorageName
, sizeof (LEGACY_BOOT_NV_DATA
), (UINT8
*) CurrentNVMap
, NULL
);
1065 This call back function is registered with Boot Manager formset.
1066 When user selects a boot option, this call back function will
1067 be triggered. The boot option is saved for later processing.
1070 @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
1071 @param Action Specifies the type of action taken by the browser.
1072 @param QuestionId A unique value which is sent to the original exporting driver
1073 so that it can identify the type of data to expect.
1074 @param Type The type of value for the question.
1075 @param Value A pointer to the data being sent to the original exporting driver.
1076 @param ActionRequest On return, points to the action requested by the callback function.
1078 @retval EFI_SUCCESS The callback successfully handled the action.
1079 @retval EFI_INVALID_PARAMETER The setup browser call this function with invalid parameters.
1084 LegacyBootOptionCallback (
1085 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL
*This
,
1086 IN EFI_BROWSER_ACTION Action
,
1087 IN EFI_QUESTION_ID QuestionId
,
1089 IN EFI_IFR_TYPE_VALUE
*Value
,
1090 OUT EFI_BROWSER_ACTION_REQUEST
*ActionRequest
1093 if (Action
!= EFI_BROWSER_ACTION_CHANGED
&& Action
!= EFI_BROWSER_ACTION_CHANGING
) {
1095 // Do nothing for other UEFI Action. Only do call back when data is changed.
1097 return EFI_UNSUPPORTED
;
1100 if ((Value
== NULL
) || (ActionRequest
== NULL
)) {
1101 return EFI_INVALID_PARAMETER
;
1104 if (Action
== EFI_BROWSER_ACTION_CHANGING
) {
1105 switch (QuestionId
) {
1106 case FORM_FLOPPY_BOOT_ID
:
1107 case FORM_HARDDISK_BOOT_ID
:
1108 case FORM_CDROM_BOOT_ID
:
1109 case FORM_NET_BOOT_ID
:
1110 case FORM_BEV_BOOT_ID
:
1111 UpdateLegacyDeviceOrderPage (QuestionId
);
1117 } else if (Action
== EFI_BROWSER_ACTION_CHANGED
) {
1118 if ((Value
== NULL
) || (ActionRequest
== NULL
)) {
1119 return EFI_INVALID_PARAMETER
;
1122 if ((QuestionId
>= LEGACY_FD_QUESTION_ID
) && (QuestionId
< LEGACY_BEV_QUESTION_ID
+ MAX_MENU_NUMBER
)) {
1123 AdjustOptionValue(QuestionId
, Value
);
1131 Create a menu entry by given menu type.
1133 @param MenuType The Menu type to be created.
1135 @retval NULL If failed to create the menu.
1136 @return the new menu entry.
1144 LEGACY_MENU_ENTRY
*MenuEntry
;
1147 // Create new menu entry
1149 MenuEntry
= AllocateZeroPool (sizeof (LEGACY_MENU_ENTRY
));
1150 if (MenuEntry
== NULL
) {
1154 MenuEntry
->VariableContext
= AllocateZeroPool (sizeof (LEGACY_DEVICE_CONTEXT
));
1155 if (MenuEntry
->VariableContext
== NULL
) {
1156 FreePool (MenuEntry
);
1160 MenuEntry
->Signature
= LEGACY_MENU_ENTRY_SIGNATURE
;
1166 Base on the L"LegacyDevOrder" variable to build the current order data.
1170 GetLegacyOptionsOrder (
1177 LEGACY_DEV_ORDER_ENTRY
*DevOrder
;
1180 LEGACY_MENU_OPTION
*OptionMenu
;
1190 DisMap
= ZeroMem (mLegacyBootOptionPrivate
->MaintainMapData
->DisableMap
, sizeof (mLegacyBootOptionPrivate
->MaintainMapData
->DisableMap
));
1193 // Get Device Order from variable
1195 GetVariable2 (VAR_LEGACY_DEV_ORDER
, &gEfiLegacyDevOrderVariableGuid
, (VOID
**) &VarData
, &VarSize
);
1197 if (NULL
!= VarData
) {
1198 DevOrder
= (LEGACY_DEV_ORDER_ENTRY
*) VarData
;
1199 while (VarData
< VarTmp
+ VarSize
) {
1200 switch (DevOrder
->BbsType
) {
1202 LegacyDev
= mLegacyBootOptionPrivate
->MaintainMapData
->InitialNvData
.LegacyFD
;
1203 OptionMenu
= &LegacyFDMenu
;
1207 LegacyDev
= mLegacyBootOptionPrivate
->MaintainMapData
->InitialNvData
.LegacyHD
;
1208 OptionMenu
= &LegacyHDMenu
;
1212 LegacyDev
= mLegacyBootOptionPrivate
->MaintainMapData
->InitialNvData
.LegacyCD
;
1213 OptionMenu
= &LegacyCDMenu
;
1216 case BBS_EMBED_NETWORK
:
1217 LegacyDev
= mLegacyBootOptionPrivate
->MaintainMapData
->InitialNvData
.LegacyNET
;
1218 OptionMenu
= &LegacyNETMenu
;
1221 case BBS_BEV_DEVICE
:
1222 LegacyDev
= mLegacyBootOptionPrivate
->MaintainMapData
->InitialNvData
.LegacyBEV
;
1223 OptionMenu
= &LegacyBEVMenu
;
1229 DEBUG ((DEBUG_ERROR
, "Unsupported device type found!\n"));
1234 // Create oneof tag here for FD/HD/CD #1 #2
1236 for (Index
= 0; Index
< OptionMenu
->MenuNumber
; Index
++) {
1237 TotalLength
= sizeof (BBS_TYPE
) + sizeof (UINT16
) + Index
* sizeof (UINT16
);
1238 VarDevOrder
= *(UINT16
*) ((UINT8
*) DevOrder
+ TotalLength
);
1240 if (0xFF00 == (VarDevOrder
& 0xFF00)) {
1241 LegacyDev
[Index
] = 0xFF;
1242 Pos
= (VarDevOrder
& 0xFF) / 8;
1243 Bit
= 7 - ((VarDevOrder
& 0xFF) % 8);
1244 DisMap
[Pos
] = (UINT8
) (DisMap
[Pos
] | (UINT8
) (1 << Bit
));
1246 LegacyDev
[Index
] = VarDevOrder
& 0xFF;
1251 VarData
+= *(UINT16
*) VarData
;
1252 DevOrder
= (LEGACY_DEV_ORDER_ENTRY
*) VarData
;
1256 CopyMem (&mLegacyBootOptionPrivate
->MaintainMapData
->LastTimeNvData
, &mLegacyBootOptionPrivate
->MaintainMapData
->InitialNvData
, sizeof (LEGACY_BOOT_NV_DATA
));
1257 CopyMem (&mLegacyBootOptionPrivate
->MaintainMapData
->CurrentNvData
, &mLegacyBootOptionPrivate
->MaintainMapData
->InitialNvData
, sizeof (LEGACY_BOOT_NV_DATA
));
1262 Build the LegacyFDMenu LegacyHDMenu LegacyCDMenu according to LegacyBios.GetBbsInfo().
1270 LEGACY_MENU_ENTRY
*NewMenuEntry
;
1271 LEGACY_DEVICE_CONTEXT
*NewLegacyDevContext
;
1272 EFI_BOOT_MANAGER_LOAD_OPTION
*BootOption
;
1273 UINTN BootOptionCount
;
1282 // Initialize Bbs Table Context from BBS info data
1284 InitializeListHead (&LegacyFDMenu
.Head
);
1285 InitializeListHead (&LegacyHDMenu
.Head
);
1286 InitializeListHead (&LegacyCDMenu
.Head
);
1287 InitializeListHead (&LegacyNETMenu
.Head
);
1288 InitializeListHead (&LegacyBEVMenu
.Head
);
1296 EfiBootManagerConnectAll ();
1299 // for better user experience
1300 // 1. User changes HD configuration (e.g.: unplug HDD), here we have a chance to remove the HDD boot option
1301 // 2. User enables/disables UEFI PXE, here we have a chance to add/remove EFI Network boot option
1303 EfiBootManagerRefreshAllBootOption ();
1305 BootOption
= EfiBootManagerGetLoadOptions (&BootOptionCount
, LoadOptionTypeBoot
);
1306 for (Index
= 0; Index
< BootOptionCount
; Index
++) {
1307 if ((DevicePathType (BootOption
[Index
].FilePath
) != BBS_DEVICE_PATH
) ||
1308 (DevicePathSubType (BootOption
[Index
].FilePath
) != BBS_BBS_DP
)
1312 ASSERT (BootOption
[Index
].OptionalDataSize
== sizeof (LEGACY_BOOT_OPTION_BBS_DATA
));
1313 NewMenuEntry
= CreateMenuEntry ();
1314 ASSERT (NewMenuEntry
!= NULL
);
1316 NewLegacyDevContext
= (LEGACY_DEVICE_CONTEXT
*) NewMenuEntry
->VariableContext
;
1317 NewLegacyDevContext
->BbsIndex
= ((LEGACY_BOOT_OPTION_BBS_DATA
*) BootOption
[Index
].OptionalData
)->BbsIndex
;
1318 NewLegacyDevContext
->Description
= AllocateCopyPool (StrSize (BootOption
[Index
].Description
), BootOption
[Index
].Description
);
1319 ASSERT (NewLegacyDevContext
->Description
!= NULL
);
1321 NewMenuEntry
->DisplayString
= NewLegacyDevContext
->Description
;
1322 NewMenuEntry
->HelpString
= NULL
;
1324 switch (((BBS_BBS_DEVICE_PATH
*) BootOption
[Index
].FilePath
)->DeviceType
) {
1325 case BBS_TYPE_FLOPPY
:
1326 InsertTailList (&LegacyFDMenu
.Head
, &NewMenuEntry
->Link
);
1330 case BBS_TYPE_HARDDRIVE
:
1331 InsertTailList (&LegacyHDMenu
.Head
, &NewMenuEntry
->Link
);
1335 case BBS_TYPE_CDROM
:
1336 InsertTailList (&LegacyCDMenu
.Head
, &NewMenuEntry
->Link
);
1340 case BBS_TYPE_EMBEDDED_NETWORK
:
1341 InsertTailList (&LegacyNETMenu
.Head
, &NewMenuEntry
->Link
);
1346 InsertTailList (&LegacyBEVMenu
.Head
, &NewMenuEntry
->Link
);
1352 EfiBootManagerFreeLoadOptions (BootOption
, BootOptionCount
);
1354 LegacyFDMenu
.MenuNumber
= FDNum
;
1355 LegacyHDMenu
.MenuNumber
= HDNum
;
1356 LegacyCDMenu
.MenuNumber
= CDNum
;
1357 LegacyNETMenu
.MenuNumber
= NETNum
;
1358 LegacyBEVMenu
.MenuNumber
= BEVNum
;
1364 Install Boot Manager Menu driver.
1366 @param ImageHandle The image handle.
1367 @param SystemTable The system table.
1369 @retval EFI_SUCEESS Install Boot manager menu success.
1370 @retval Other Return error status.
1375 LegacyBootMaintUiLibConstructor (
1376 IN EFI_HANDLE ImageHandle
,
1377 IN EFI_SYSTEM_TABLE
*SystemTable
1381 EFI_LEGACY_BIOS_PROTOCOL
*LegacyBios
;
1382 LEGACY_BOOT_OPTION_CALLBACK_DATA
*LegacyBootOptionData
;
1384 Status
= gBS
->LocateProtocol (&gEfiLegacyBiosProtocolGuid
, NULL
, (VOID
**) &LegacyBios
);
1385 if (!EFI_ERROR (Status
)) {
1387 // Create LegacyBootOptionData structures for Driver Callback
1389 LegacyBootOptionData
= AllocateZeroPool (sizeof (LEGACY_BOOT_OPTION_CALLBACK_DATA
));
1390 ASSERT (LegacyBootOptionData
!= NULL
);
1392 LegacyBootOptionData
->MaintainMapData
= AllocateZeroPool (sizeof (LEGACY_BOOT_MAINTAIN_DATA
));
1393 ASSERT (LegacyBootOptionData
->MaintainMapData
!= NULL
);
1395 LegacyBootOptionData
->ConfigAccess
.ExtractConfig
= LegacyBootOptionExtractConfig
;
1396 LegacyBootOptionData
->ConfigAccess
.RouteConfig
= LegacyBootOptionRouteConfig
;
1397 LegacyBootOptionData
->ConfigAccess
.Callback
= LegacyBootOptionCallback
;
1400 // Install Device Path Protocol and Config Access protocol to driver handle
1402 Status
= gBS
->InstallMultipleProtocolInterfaces (
1403 &LegacyBootOptionData
->DriverHandle
,
1404 &gEfiDevicePathProtocolGuid
,
1405 &mLegacyBootOptionHiiVendorDevicePath
,
1406 &gEfiHiiConfigAccessProtocolGuid
,
1407 &LegacyBootOptionData
->ConfigAccess
,
1410 ASSERT_EFI_ERROR (Status
);
1413 // Publish our HII data
1415 LegacyBootOptionData
->HiiHandle
= HiiAddPackages (
1416 &mLegacyBootOptionGuid
,
1417 LegacyBootOptionData
->DriverHandle
,
1418 LegacyBootMaintUiVfrBin
,
1419 LegacyBootMaintUiLibStrings
,
1422 ASSERT (LegacyBootOptionData
->HiiHandle
!= NULL
);
1424 mLegacyBootOptionPrivate
= LegacyBootOptionData
;
1426 GetLegacyOptions ();
1428 GetLegacyOptionsOrder();
1435 Destructor of Customized Display Library Instance.
1437 @param ImageHandle The firmware allocated handle for the EFI image.
1438 @param SystemTable A pointer to the EFI System Table.
1440 @retval EFI_SUCCESS The destructor completed successfully.
1441 @retval Other value The destructor did not complete successfully.
1446 LegacyBootMaintUiLibDestructor (
1447 IN EFI_HANDLE ImageHandle
,
1448 IN EFI_SYSTEM_TABLE
*SystemTable
1453 if (mLegacyBootOptionPrivate
->DriverHandle
!= NULL
) {
1454 Status
= gBS
->UninstallMultipleProtocolInterfaces (
1455 mLegacyBootOptionPrivate
->DriverHandle
,
1456 &gEfiDevicePathProtocolGuid
,
1457 &mLegacyBootOptionHiiVendorDevicePath
,
1458 &gEfiHiiConfigAccessProtocolGuid
,
1459 &mLegacyBootOptionPrivate
->ConfigAccess
,
1462 ASSERT_EFI_ERROR (Status
);
1464 HiiRemovePackages (mLegacyBootOptionPrivate
->HiiHandle
);
1466 FreePool (mLegacyBootOptionPrivate
->MaintainMapData
);
1467 FreePool (mLegacyBootOptionPrivate
);