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