]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Universal/PlatformDriverOverride/PlatOverMngr/PlatOverMngr.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
enhanced security check.
[mirror_edk2.git] / MdeModulePkg / Universal / PlatformDriverOverride / PlatOverMngr / PlatOverMngr.c
1 /** @file
2
3 A UI application to offer a UI interface in device manager to let user configue
4 platform override protocol to override the default algorithm for matching
5 drivers to controllers.
6
7 The main flow:
8 1. The UI application dynamicly locate all controller device path.
9 2. The UI application dynamicly locate all drivers which support binding protocol.
10 3. The UI application export and dynamicly update two menu to let user select the
11 mapping between drivers to controllers.
12 4. The UI application save all the mapping info in NV variables which will be consumed
13 by platform override protocol driver to publish the platform override protocol.
14
15 Copyright (c) 2007 - 2008, Intel Corporation
16 All rights reserved. This program and the accompanying materials
17 are licensed and made available under the terms and conditions of the BSD License
18 which accompanies this distribution. The full text of the license may be found at
19 http://opensource.org/licenses/bsd-license.php
20
21 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
22 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
23
24 **/
25
26 #include <PiDxe.h>
27
28 #include <Protocol/HiiConfigAccess.h>
29 #include <Protocol/HiiConfigRouting.h>
30 #include <Protocol/HiiDatabase.h>
31 #include <Protocol/FormBrowser2.h>
32 #include <Protocol/LoadedImage.h>
33 #include <Protocol/FirmwareVolume2.h>
34 #include <Protocol/PciIo.h>
35 #include <Protocol/BusSpecificDriverOverride.h>
36 #include <Protocol/ComponentName2.h>
37 #include <Protocol/ComponentName.h>
38 #include <Protocol/DriverBinding.h>
39 #include <Guid/GlobalVariable.h>
40
41 #include <Library/BaseLib.h>
42 #include <Library/DebugLib.h>
43 #include <Library/UefiLib.h>
44 #include <Library/UefiApplicationEntryPoint.h>
45 #include <Library/UefiBootServicesTableLib.h>
46 #include <Library/PlatDriOverLib.h>
47 #include <Library/HiiLib.h>
48 #include <Library/IfrSupportLib.h>
49 #include <Library/ExtendedHiiLib.h>
50 #include <Library/ExtendedIfrSupportLib.h>
51 #include <Library/BaseMemoryLib.h>
52 #include <Library/MemoryAllocationLib.h>
53 #include <Library/UefiRuntimeServicesTableLib.h>
54 #include <Library/DevicePathLib.h>
55 #include <Library/GenericBdsLib.h>
56 #include "PlatOverMngr.h"
57
58 #define EFI_CALLBACK_INFO_SIGNATURE SIGNATURE_32 ('C', 'l', 'b', 'k')
59 #define EFI_CALLBACK_INFO_FROM_THIS(a) CR (a, EFI_CALLBACK_INFO, ConfigAccess, EFI_CALLBACK_INFO_SIGNATURE)
60
61 typedef struct {
62 UINTN Signature;
63 EFI_HANDLE DriverHandle;
64 EFI_HII_HANDLE RegisteredHandle;
65 PLAT_OVER_MNGR_DATA FakeNvData;
66 EFI_HII_CONFIG_ROUTING_PROTOCOL *HiiConfigRouting;
67 EFI_HII_CONFIG_ACCESS_PROTOCOL ConfigAccess;
68 } EFI_CALLBACK_INFO;
69
70 //
71 // uni string and Vfr Binary data.
72 //
73 extern UINT8 VfrBin[];
74 extern UINT8 PlatOverMngrStrings[];
75
76 //
77 // module global data
78 //
79 EFI_GUID mPlatformOverridesManagerGuid = PLAT_OVER_MNGR_GUID;
80 LIST_ENTRY mMappingDataBase = INITIALIZE_LIST_HEAD_VARIABLE (mMappingDataBase);
81
82 EFI_HANDLE *mDevicePathHandleBuffer;
83 EFI_HANDLE *mDriverImageHandleBuffer;
84
85 INTN mSelectedCtrIndex;
86 EFI_STRING_ID mControllerToken[MAX_CHOICE_NUM];
87 UINTN mDriverImageHandleCount;
88 EFI_STRING_ID mDriverImageToken[MAX_CHOICE_NUM];
89 EFI_STRING_ID mDriverImageFilePathToken[MAX_CHOICE_NUM];
90 EFI_LOADED_IMAGE_PROTOCOL *mDriverImageProtocol[MAX_CHOICE_NUM];
91 EFI_DEVICE_PATH_PROTOCOL *mControllerDevicePathProtocol[MAX_CHOICE_NUM];
92 UINTN mSelectedDriverImageNum;
93 UINTN mLastSavedDriverImageNum;
94 CHAR8 mLanguage[RFC_3066_ENTRY_SIZE];
95 UINT16 mCurrentPage;
96
97 /**
98 Do string convertion for the ComponentName supported language. It do
99 the convertion just for english language code from RFC 3066 to ISO 639-2.
100 Then it will check whether the converted language is in the supported language list.
101 If not supported, NULL is returned.
102 If Language is not english, NULL is returned.
103
104 @param SupportedLanguages Pointer to ComponentName supported language string list. ISO 639-2 language
105 @param Language The language string. RFC 3066 language
106
107 @return English language string (ISO 639-2)
108 @return NULL if the conertion is not successful.
109
110 **/
111 CHAR8 *
112 ConvertComponentNameSupportLanguage (
113 IN CHAR8 *SupportedLanguages,
114 IN CHAR8 *Language
115 )
116 {
117 CHAR8 *LangCode;
118 LangCode = NULL;
119
120 //
121 // Check the input language is English
122 //
123 if (AsciiStrnCmp (Language, "en-", 3) != 0) {
124 return NULL;
125 }
126
127 //
128 // Check SupportedLanguages format
129 //
130 if (AsciiStrStr (SupportedLanguages, "en-") != NULL) {
131 //
132 // Create RFC 3066 language
133 //
134 LangCode = AllocateZeroPool(AsciiStrSize (Language));
135 AsciiStrCpy (LangCode, Language);
136 } else if (AsciiStrStr (SupportedLanguages, "en") != NULL) {
137 //
138 // Create ISO 639-2 Language
139 //
140 LangCode = AllocateZeroPool(4);
141 AsciiStrCpy (LangCode, "eng");
142 }
143
144 return LangCode;
145 }
146
147 /**
148 Get the driver name by ComponentName or ComponentName2 protocol
149 according to the driver binding handle
150
151 @param DriverBindingHandle The Handle of DriverBinding.
152
153 @retval !NULL Pointer into the image name if the image name is found,
154 @retval NULL Pointer to NULL if the image name is not found.
155
156 **/
157 CHAR16 *
158 GetComponentName (
159 IN EFI_HANDLE DriverBindingHandle
160 )
161 {
162 EFI_STATUS Status;
163 EFI_COMPONENT_NAME_PROTOCOL *ComponentName;
164 EFI_COMPONENT_NAME2_PROTOCOL *ComponentName2;
165 CHAR8 *SupportedLanguage;
166 CHAR16 *DriverName;
167
168 ComponentName = NULL;
169 ComponentName2 = NULL;
170 Status = gBS->OpenProtocol (
171 DriverBindingHandle,
172 &gEfiComponentName2ProtocolGuid,
173 (VOID **) &ComponentName2,
174 NULL,
175 NULL,
176 EFI_OPEN_PROTOCOL_GET_PROTOCOL
177 );
178 if (EFI_ERROR(Status)) {
179 Status = gBS->OpenProtocol (
180 DriverBindingHandle,
181 &gEfiComponentNameProtocolGuid,
182 (VOID **) &ComponentName,
183 NULL,
184 NULL,
185 EFI_OPEN_PROTOCOL_GET_PROTOCOL
186 );
187 }
188
189 Status = EFI_SUCCESS;
190 DriverName = NULL;
191 if (ComponentName != NULL) {
192 if (ComponentName->GetDriverName != NULL) {
193 SupportedLanguage = ConvertComponentNameSupportLanguage (ComponentName->SupportedLanguages, mLanguage);
194 if (SupportedLanguage != NULL) {
195 Status = ComponentName->GetDriverName (
196 ComponentName,
197 SupportedLanguage,
198 &DriverName
199 );
200 FreePool (SupportedLanguage);
201 }
202 }
203 } else if (ComponentName2 != NULL) {
204 if (ComponentName2->GetDriverName != NULL) {
205 Status = ComponentName2->GetDriverName (
206 ComponentName2,
207 mLanguage,
208 &DriverName
209 );
210 }
211 }
212
213 if (EFI_ERROR (Status)) {
214 return NULL;
215 }
216
217 return DriverName;
218 }
219
220 /**
221 Get the image name from EFI UI section.
222 Get FV protocol by its loaded image protoocl to abastract EFI UI section.
223
224 @param Image Pointer to the loaded image protocol
225
226 @retval !NULL Pointer to the image name if the image name is found,
227 @retval NULL NULL if the image name is not found.
228
229 **/
230 CHAR16 *
231 GetImageName (
232 IN EFI_LOADED_IMAGE_PROTOCOL *Image
233 )
234 {
235 EFI_STATUS Status;
236 EFI_DEVICE_PATH_PROTOCOL *DevPathNode;
237 EFI_DEVICE_PATH_PROTOCOL *AlignedDevPathNode;
238 MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *FvFilePath;
239 VOID *Buffer;
240 UINTN BufferSize;
241 UINT32 AuthenticationStatus;
242 EFI_GUID *NameGuid;
243 EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv2;
244
245 Fv2 = NULL;
246 Buffer = NULL;
247 BufferSize = 0;
248
249 if (Image->FilePath == NULL) {
250 return NULL;
251 }
252 DevPathNode = Image->FilePath;
253
254 while (!IsDevicePathEnd (DevPathNode)) {
255 //
256 // Make sure device path node is aligned when accessing it's FV Name Guid field.
257 //
258 AlignedDevPathNode = AllocateCopyPool (DevicePathNodeLength(DevPathNode), DevPathNode);
259
260 //
261 // Find the Fv File path
262 //
263 NameGuid = EfiGetNameGuidFromFwVolDevicePathNode ((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *)AlignedDevPathNode);
264 if (NameGuid != NULL) {
265 FvFilePath = (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) AlignedDevPathNode;
266 Status = gBS->HandleProtocol (
267 Image->DeviceHandle,
268 &gEfiFirmwareVolume2ProtocolGuid,
269 (VOID **) &Fv2
270 );
271 //
272 // Locate Image EFI UI section to get the image name.
273 //
274 if (!EFI_ERROR (Status)) {
275 Status = Fv2->ReadSection (
276 Fv2,
277 &FvFilePath->FvFileName,
278 EFI_SECTION_USER_INTERFACE,
279 0,
280 &Buffer,
281 &BufferSize,
282 &AuthenticationStatus
283 );
284 if (!EFI_ERROR (Status)) {
285 FreePool (AlignedDevPathNode);
286 break;
287 }
288 Buffer = NULL;
289 }
290 }
291
292 FreePool (AlignedDevPathNode);
293
294 //
295 // Next device path node
296 //
297 DevPathNode = NextDevicePathNode (DevPathNode);
298 }
299
300 return Buffer;
301 }
302
303 /**
304 Prepare the first page to let user select the device controller which need to
305 add mapping drivers if user select 'Refresh' in first page.
306 During first page, user will see all currnet controller device path in system,
307 select any device path will go to second page to select its overrides drivers.
308
309 @param Private Pointer to EFI_CALLBACK_INFO.
310 @param KeyValue The callback key value of device controller item in first page.
311 @param FakeNvData Pointer to PLAT_OVER_MNGR_DATA.
312
313 @retval EFI_SUCCESS Always returned.
314
315 **/
316 EFI_STATUS
317 UpdateDeviceSelectPage (
318 IN EFI_CALLBACK_INFO *Private,
319 IN UINT16 KeyValue,
320 IN PLAT_OVER_MNGR_DATA *FakeNvData
321 )
322 {
323 EFI_HII_UPDATE_DATA UpdateData;
324 EFI_STATUS Status;
325 UINTN LangSize;
326 UINTN Index;
327 UINTN DevicePathHandleCount;
328 CHAR16 *NewString;
329 EFI_STRING_ID NewStringToken;
330 CHAR16 *ControllerName;
331 EFI_DEVICE_PATH_PROTOCOL *ControllerDevicePath;
332 EFI_PCI_IO_PROTOCOL *PciIo;
333 EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL *BusSpecificDriverOverride;
334 UINTN Len;
335
336 //
337 // set current page form ID.
338 //
339 mCurrentPage = FORM_ID_DEVICE;
340
341 //
342 // Get Platform supported Language (RFC_3066 format)
343 //
344 LangSize = RFC_3066_ENTRY_SIZE;
345 Status = gRT->GetVariable (
346 L"PlatformLang",
347 &gEfiGlobalVariableGuid,
348 NULL,
349 &LangSize,
350 mLanguage
351 );
352 ASSERT_EFI_ERROR (Status);
353
354 //
355 // Initial the mapping database in memory
356 //
357 FreeMappingDatabase (&mMappingDataBase);
358 Status = InitOverridesMapping (&mMappingDataBase);
359
360 //
361 // Clear all the content in the first page
362 //
363 UpdateData.BufferSize = UPDATE_DATA_SIZE;
364 UpdateData.Offset = 0;
365 UpdateData.Data = AllocateZeroPool (UPDATE_DATA_SIZE);
366 ASSERT (UpdateData.Data != NULL);
367 //
368 // Clear first page form
369 //
370 IfrLibUpdateForm (
371 Private->RegisteredHandle,
372 &mPlatformOverridesManagerGuid,
373 FORM_ID_DEVICE,
374 FORM_ID_DEVICE,
375 FALSE,
376 &UpdateData
377 );
378
379 //
380 // When user enter the page at first time, the 'first refresh' string is given to notify user to refresh all the drivers,
381 // then the 'first refresh' string will be replaced by the 'refresh' string, and the two strings content are same after the replacement
382 //
383 NewStringToken = STRING_TOKEN (STR_FIRST_REFRESH);
384 HiiLibGetStringFromHandle (Private->RegisteredHandle, STRING_TOKEN (STR_REFRESH), &NewString);
385 ASSERT (NewString != NULL);
386 Status = HiiLibSetString (Private->RegisteredHandle, NewStringToken, NewString);
387 ASSERT_EFI_ERROR (Status);
388 FreePool (NewString);
389
390 NewStringToken = STRING_TOKEN (STR_FIRST_REFRESH_HELP);
391 HiiLibGetStringFromHandle (Private->RegisteredHandle, STRING_TOKEN (STR_REFRESH_HELP), &NewString);
392 ASSERT (NewString != NULL);
393 Status = HiiLibSetString (Private->RegisteredHandle, NewStringToken, NewString);
394 ASSERT_EFI_ERROR (Status);
395 FreePool (NewString);
396
397 //
398 // created needed controller device item in first page
399 //
400 DevicePathHandleCount = 0;
401 Status = gBS->LocateHandleBuffer (
402 ByProtocol,
403 &gEfiDevicePathProtocolGuid,
404 NULL,
405 &DevicePathHandleCount,
406 &mDevicePathHandleBuffer
407 );
408 if (EFI_ERROR (Status) || (DevicePathHandleCount == 0)) {
409 return EFI_SUCCESS;
410 }
411
412 for (Index = 0; Index < DevicePathHandleCount; Index++) {
413 if (FakeNvData->PciDeviceFilter == 0x01) {
414 //
415 // Only care PCI device which contain efi driver in its option rom.
416 //
417
418 //
419 // Check whether it is a pci device
420 //
421 ControllerDevicePath = NULL;
422 Status = gBS->OpenProtocol (
423 mDevicePathHandleBuffer[Index],
424 &gEfiPciIoProtocolGuid,
425 (VOID **) &PciIo,
426 NULL,
427 NULL,
428 EFI_OPEN_PROTOCOL_GET_PROTOCOL
429 );
430 if (EFI_ERROR (Status)) {
431 continue;
432 }
433 //
434 // Check whether it contain efi driver in its option rom
435 //
436 Status = gBS->HandleProtocol(
437 mDevicePathHandleBuffer[Index],
438 &gEfiBusSpecificDriverOverrideProtocolGuid,
439 (VOID **) &BusSpecificDriverOverride
440 );
441 if (EFI_ERROR (Status) || BusSpecificDriverOverride == NULL) {
442 continue;
443 }
444 }
445
446 ControllerDevicePath = NULL;
447 Status = gBS->OpenProtocol (
448 mDevicePathHandleBuffer[Index],
449 &gEfiDevicePathProtocolGuid,
450 (VOID **) &ControllerDevicePath,
451 NULL,
452 NULL,
453 EFI_OPEN_PROTOCOL_GET_PROTOCOL
454 );
455 ASSERT_EFI_ERROR (Status);
456 //
457 // Save the device path protocol interface
458 //
459 mControllerDevicePathProtocol[Index] = ControllerDevicePath;
460
461 //
462 // Get the driver name
463 //
464 ControllerName = DevicePathToStr (ControllerDevicePath);
465
466 //
467 // Export the driver name string and create item in set options page
468 //
469 Len = StrSize (ControllerName);
470 NewString = AllocateZeroPool (Len + StrSize (L"--"));
471 ASSERT (NewString != NULL);
472 if (EFI_ERROR (CheckMapping (ControllerDevicePath,NULL, &mMappingDataBase, NULL, NULL))) {
473 StrCat (NewString, L"--");
474 } else {
475 StrCat (NewString, L"**");
476 }
477 StrCat (NewString, ControllerName);
478
479 NewStringToken = mControllerToken[Index];
480 if (NewStringToken == 0) {
481 Status = HiiLibNewString (Private->RegisteredHandle, &NewStringToken, NewString);
482 } else {
483 Status = HiiLibSetString (Private->RegisteredHandle, NewStringToken, NewString);
484 }
485 ASSERT_EFI_ERROR (Status);
486 FreePool (NewString);
487 //
488 // Save the device path string toke for next access use
489 //
490 mControllerToken[Index] = NewStringToken;
491
492 CreateGotoOpCode (
493 FORM_ID_DRIVER,
494 NewStringToken,
495 STRING_TOKEN (STR_GOTO_HELP_DRIVER),
496 EFI_IFR_FLAG_CALLBACK,
497 (UINT16) (Index + KEY_VALUE_DEVICE_OFFSET),
498 &UpdateData
499 );
500 }
501
502 //
503 // Update first page form
504 //
505 IfrLibUpdateForm (
506 Private->RegisteredHandle,
507 &mPlatformOverridesManagerGuid,
508 FORM_ID_DEVICE,
509 FORM_ID_DEVICE,
510 FALSE,
511 &UpdateData
512 );
513
514 FreePool (UpdateData.Data);
515 return EFI_SUCCESS;
516 }
517
518 /**
519 Get the first Driver Binding handle which has the specific image handle.
520
521 @param ImageHandle The Image handle
522
523 @return Handle to Driver binding
524 @retval NULL The paramter is not valid or the driver binding handle is not found.
525
526 **/
527 EFI_HANDLE
528 GetDriverBindingHandleFromImageHandle (
529 IN EFI_HANDLE ImageHandle
530 )
531 {
532 EFI_STATUS Status;
533 UINTN Index;
534 UINTN DriverBindingHandleCount;
535 EFI_HANDLE *DriverBindingHandleBuffer;
536 EFI_DRIVER_BINDING_PROTOCOL *DriverBindingInterface;
537 EFI_HANDLE DriverBindingHandle;
538
539 DriverBindingHandle = NULL;
540
541 if (ImageHandle == NULL) {
542 return NULL;
543 }
544 //
545 // Get all drivers which support driver binding protocol
546 //
547 DriverBindingHandleCount = 0;
548 Status = gBS->LocateHandleBuffer (
549 ByProtocol,
550 &gEfiDriverBindingProtocolGuid,
551 NULL,
552 &DriverBindingHandleCount,
553 &DriverBindingHandleBuffer
554 );
555 if (EFI_ERROR (Status) || (DriverBindingHandleCount == 0)) {
556 return NULL;
557 }
558
559 //
560 // Get the first Driver Binding handle which has the specific image handle.
561 //
562 for (Index = 0; Index < DriverBindingHandleCount; Index++) {
563 DriverBindingInterface = NULL;
564 Status = gBS->OpenProtocol (
565 DriverBindingHandleBuffer[Index],
566 &gEfiDriverBindingProtocolGuid,
567 (VOID **) &DriverBindingInterface,
568 NULL,
569 NULL,
570 EFI_OPEN_PROTOCOL_GET_PROTOCOL
571 );
572 if (EFI_ERROR (Status)) {
573 continue;
574 }
575
576 if (DriverBindingInterface->ImageHandle == ImageHandle) {
577 DriverBindingHandle = DriverBindingHandleBuffer[Index];
578 break;
579 }
580 }
581
582 FreePool (DriverBindingHandleBuffer);
583 return DriverBindingHandle;
584 }
585
586 /**
587 Prepare to let user select the drivers which need mapping with the device controller
588 selected in first page.
589
590 @param Private Pointer to EFI_CALLBACK_INFO.
591 @param KeyValue The callback key value of device controller item in first page.
592 KeyValue is larger than or equal to KEY_VALUE_DEVICE_OFFSET.
593 @param FakeNvData Pointer to PLAT_OVER_MNGR_DATA.
594
595 @retval EFI_SUCCESS Always returned.
596
597 **/
598 EFI_STATUS
599 UpdateBindingDriverSelectPage (
600 IN EFI_CALLBACK_INFO *Private,
601 IN UINT16 KeyValue,
602 IN PLAT_OVER_MNGR_DATA *FakeNvData
603 )
604 {
605 EFI_HII_UPDATE_DATA UpdateData;
606 EFI_STATUS Status;
607 UINTN Index;
608 CHAR16 *NewString;
609 EFI_STRING_ID NewStringToken;
610 EFI_STRING_ID NewStringHelpToken;
611 UINTN DriverImageHandleCount;
612 EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
613 CHAR16 *DriverName;
614 BOOLEAN FreeDriverName;
615 EFI_DEVICE_PATH_PROTOCOL *LoadedImageDevicePath;
616 EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL *BusSpecificDriverOverride;
617 EFI_HANDLE DriverBindingHandle;
618
619 //
620 // If user select a controller item in the first page the following code will be run.
621 // During second page, user will see all currnet driver bind protocol driver, the driver name and its device path will be shown
622 //
623 //First acquire the list of Loaded Image Protocols, and then when want the name of the driver, look up all the Driver Binding Protocols
624 // and find the first one whose ImageHandle field matches the image handle of the Loaded Image Protocol.
625 // then use the Component Name Protocol on the same handle as the first matching Driver Binding Protocol to look up the name of the driver.
626 //
627
628 mCurrentPage = FORM_ID_DRIVER;
629 //
630 // Switch the item callback key value to its NO. in mDevicePathHandleBuffer
631 //
632 mSelectedCtrIndex = KeyValue - KEY_VALUE_DEVICE_OFFSET;
633 ASSERT (mSelectedCtrIndex > 0 && mSelectedCtrIndex < MAX_CHOICE_NUM);
634
635 mLastSavedDriverImageNum = 0;
636 //
637 // Clear all the content in dynamic page
638 //
639 UpdateData.BufferSize = UPDATE_DATA_SIZE;
640 UpdateData.Offset = 0;
641 UpdateData.Data = AllocateZeroPool (UPDATE_DATA_SIZE);
642 ASSERT (UpdateData.Data != NULL);
643 //
644 // Clear second page form
645 //
646 IfrLibUpdateForm (
647 Private->RegisteredHandle,
648 &mPlatformOverridesManagerGuid,
649 FORM_ID_DRIVER,
650 FORM_ID_DRIVER,
651 FALSE,
652 &UpdateData
653 );
654
655 //
656 // Show all driver which support loaded image protocol in second page
657 //
658 DriverImageHandleCount = 0;
659 Status = gBS->LocateHandleBuffer (
660 ByProtocol,
661 &gEfiLoadedImageProtocolGuid,
662 NULL,
663 &DriverImageHandleCount,
664 &mDriverImageHandleBuffer
665 );
666 if (EFI_ERROR (Status) || (DriverImageHandleCount == 0)) {
667 return EFI_NOT_FOUND;
668 }
669
670 mDriverImageHandleCount = DriverImageHandleCount;
671 for (Index = 0; Index < DriverImageHandleCount; Index++) {
672 //
673 // Step1: Get the driver image total file path for help string and the driver name.
674 //
675
676 //
677 // Find driver's Loaded Image protocol
678 //
679 LoadedImage =NULL;
680
681 Status = gBS->OpenProtocol (
682 mDriverImageHandleBuffer[Index],
683 &gEfiLoadedImageProtocolGuid,
684 (VOID **) &LoadedImage,
685 NULL,
686 NULL,
687 EFI_OPEN_PROTOCOL_GET_PROTOCOL
688 );
689 if (EFI_ERROR (Status)) {
690 FakeNvData->DriSelection[Index] = 0x00;
691 continue;
692 }
693 mDriverImageProtocol[Index] = LoadedImage;
694 //
695 // Find its related driver binding protocol
696 //
697 DriverBindingHandle = GetDriverBindingHandleFromImageHandle (mDriverImageHandleBuffer[Index]);
698 if (DriverBindingHandle == NULL) {
699 FakeNvData->DriSelection[Index] = 0x00;
700 continue;
701 }
702
703 //
704 // Get the EFI Loaded Image Device Path Protocol
705 //
706 LoadedImageDevicePath = NULL;
707 Status = gBS->HandleProtocol (
708 mDriverImageHandleBuffer[Index],
709 &gEfiLoadedImageDevicePathProtocolGuid,
710 (VOID **) &LoadedImageDevicePath
711 );
712 if (LoadedImageDevicePath == NULL) {
713 FakeNvData->DriSelection[Index] = 0x00;
714 continue;
715 }
716
717 if (FakeNvData->PciDeviceFilter == 0x01) {
718 //
719 // only care the driver which is in a Pci device option rom,
720 // and the driver's LoadedImage->DeviceHandle must point to a pci device which has efi option rom
721 //
722 if (!EFI_ERROR (Status)) {
723 Status = gBS->HandleProtocol(
724 LoadedImage->DeviceHandle,
725 &gEfiBusSpecificDriverOverrideProtocolGuid,
726 (VOID **) &BusSpecificDriverOverride
727 );
728 if (EFI_ERROR (Status) || BusSpecificDriverOverride == NULL) {
729 FakeNvData->DriSelection[Index] = 0x00;
730 continue;
731 }
732 } else {
733 FakeNvData->DriSelection[Index] = 0x00;
734 continue;
735 }
736 }
737
738 //
739 // For driver name, try to get its component name, if fail, get its image name,
740 // if also fail, give a default name.
741 //
742 FreeDriverName = FALSE;
743 DriverName = GetComponentName (DriverBindingHandle);
744 if (DriverName == NULL) {
745 //
746 // get its image name
747 //
748 DriverName = GetImageName (LoadedImage);
749 }
750 if (DriverName == NULL) {
751 //
752 // give a default name
753 //
754 HiiLibGetStringFromHandle (Private->RegisteredHandle, STRING_TOKEN (STR_DRIVER_DEFAULT_NAME), &DriverName);
755 ASSERT (DriverName != NULL);
756 FreeDriverName = TRUE; // the DriverName string need to free pool
757 }
758
759
760 //
761 // Step2 Export the driver name string and create check box item in second page
762 //
763
764 //
765 // First create the driver image name
766 //
767 NewString = AllocateZeroPool (StrSize (DriverName));
768 ASSERT (NewString != NULL);
769 if (EFI_ERROR (CheckMapping (mControllerDevicePathProtocol[mSelectedCtrIndex], LoadedImageDevicePath, &mMappingDataBase, NULL, NULL))) {
770 FakeNvData->DriSelection[Index] = 0x00;
771 } else {
772 FakeNvData->DriSelection[Index] = 0x01;
773 mLastSavedDriverImageNum++;
774 }
775 StrCat (NewString, DriverName);
776 NewStringToken = mDriverImageToken[Index];
777 if (NewStringToken == 0) {
778 Status = HiiLibNewString (Private->RegisteredHandle, &NewStringToken, NewString);
779 } else {
780 Status = HiiLibSetString (Private->RegisteredHandle, NewStringToken, NewString);
781 }
782 mDriverImageToken[Index] = NewStringToken;
783 ASSERT_EFI_ERROR (Status);
784 FreePool (NewString);
785 if (FreeDriverName) {
786 FreePool (DriverName);
787 }
788
789 //
790 // Second create the driver image device path as item help string
791 //
792 DriverName = DevicePathToStr (LoadedImageDevicePath);
793
794 NewString = AllocateZeroPool (StrSize (DriverName));
795 ASSERT (NewString != NULL);
796 StrCat (NewString, DriverName);
797 NewStringHelpToken = mDriverImageFilePathToken[Index];
798 if (NewStringHelpToken == 0) {
799 Status = HiiLibNewString (Private->RegisteredHandle, &NewStringHelpToken, NewString);
800 } else {
801 Status = HiiLibSetString (Private->RegisteredHandle, NewStringHelpToken, NewString);
802 }
803 mDriverImageFilePathToken[Index] = NewStringHelpToken;
804 ASSERT_EFI_ERROR (Status);
805 FreePool (NewString);
806 FreePool (DriverName);
807
808 CreateCheckBoxOpCode (
809 (UINT16) (DRIVER_SELECTION_QUESTION_ID + Index),
810 VARSTORE_ID_PLAT_OVER_MNGR,
811 (UINT16) (DRIVER_SELECTION_VAR_OFFSET + Index),
812 NewStringToken,
813 NewStringHelpToken,
814 0,
815 0,
816 &UpdateData
817 );
818 }
819
820 //
821 // Update second page form
822 //
823 IfrLibUpdateForm (
824 Private->RegisteredHandle,
825 &mPlatformOverridesManagerGuid,
826 FORM_ID_DRIVER,
827 FORM_ID_DRIVER,
828 FALSE,
829 &UpdateData
830 );
831
832 FreePool (UpdateData.Data);
833 return EFI_SUCCESS;
834 }
835
836 /**
837 Prepare to let user select the priority order of the drivers which are
838 selected in second page.
839
840 @param Private Pointer to EFI_CALLBACK_INFO.
841 @param KeyValue The callback key value of device controller item in first page.
842 @param FakeNvData Pointer to PLAT_OVER_MNGR_DATA.
843
844 @retval EFI_SUCCESS Always returned.
845
846 **/
847 EFI_STATUS
848 UpdatePrioritySelectPage (
849 IN EFI_CALLBACK_INFO *Private,
850 IN UINT16 KeyValue,
851 IN PLAT_OVER_MNGR_DATA *FakeNvData
852 )
853 {
854 EFI_HII_UPDATE_DATA UpdateData;
855 UINTN Index;
856 EFI_DEVICE_PATH_PROTOCOL *LoadedImageDevicePath;
857 IFR_OPTION *IfrOptionList;
858 UINTN SelectedDriverImageNum;
859 UINT32 DriverImageNO;
860 UINTN MinNO;
861 UINTN Index1;
862 UINTN TempNO[100];
863
864 //
865 // Following code will be run if user select 'order ... priority' item in second page
866 // Prepare third page. In third page, user will order the drivers priority which are selected in second page
867 //
868 mCurrentPage = FORM_ID_ORDER;
869
870 UpdateData.BufferSize = UPDATE_DATA_SIZE;
871 UpdateData.Offset = 0;
872 UpdateData.Data = AllocateZeroPool (UPDATE_DATA_SIZE);
873 ASSERT (UpdateData.Data != NULL);
874 //
875 // Clear third page form
876 //
877 IfrLibUpdateForm (
878 Private->RegisteredHandle,
879 &mPlatformOverridesManagerGuid,
880 FORM_ID_ORDER,
881 FORM_ID_ORDER,
882 FALSE,
883 &UpdateData
884 );
885
886 //
887 // Check how many drivers have been selected
888 //
889 SelectedDriverImageNum = 0;
890 for (Index = 0; Index < mDriverImageHandleCount; Index++) {
891 if (FakeNvData->DriSelection[Index] != 0) {
892 SelectedDriverImageNum ++;
893 }
894 }
895
896 mSelectedDriverImageNum = SelectedDriverImageNum;
897 if (SelectedDriverImageNum == 0) {
898 return EFI_SUCCESS;
899 }
900
901 IfrOptionList = AllocateZeroPool (sizeof (IFR_OPTION) * mSelectedDriverImageNum);
902 ASSERT (IfrOptionList != NULL);
903 //
904 // Create order list for those selected drivers
905 //
906 SelectedDriverImageNum = 0;
907 for (Index = 0; Index < mDriverImageHandleCount; Index++) {
908 if (FakeNvData->DriSelection[Index] != 0) {
909 IfrOptionList[SelectedDriverImageNum].StringToken = mDriverImageToken[Index];
910 //
911 // Use the NO. in driver binding buffer as value, will use it later
912 //
913 IfrOptionList[SelectedDriverImageNum].Value.u8 = (UINT8) (Index + 1);
914 IfrOptionList[SelectedDriverImageNum].Flags = 0;
915
916 //
917 // Get the EFI Loaded Image Device Path Protocol
918 //
919 LoadedImageDevicePath = NULL;
920 gBS->HandleProtocol (
921 mDriverImageHandleBuffer[Index],
922 &gEfiLoadedImageDevicePathProtocolGuid,
923 (VOID **) &LoadedImageDevicePath
924 );
925 ASSERT (LoadedImageDevicePath != NULL);
926
927 //
928 // Check the driver DriverImage's order number in mapping database
929 //
930 DriverImageNO = 0;
931 ASSERT (mSelectedCtrIndex < MAX_CHOICE_NUM);
932 CheckMapping (
933 mControllerDevicePathProtocol[mSelectedCtrIndex],
934 LoadedImageDevicePath,
935 &mMappingDataBase,
936 NULL,
937 &DriverImageNO
938 );
939 if (DriverImageNO == 0) {
940 DriverImageNO = (UINT32) mLastSavedDriverImageNum + 1;
941 mLastSavedDriverImageNum++;
942 }
943 TempNO[SelectedDriverImageNum] = DriverImageNO;
944 SelectedDriverImageNum ++;
945 }
946 }
947
948 ASSERT (SelectedDriverImageNum == mSelectedDriverImageNum);
949 //
950 // NvRamMap Must be clear firstly
951 //
952 ZeroMem (FakeNvData->DriOrder, sizeof (FakeNvData->DriOrder));
953
954 //
955 // Order the selected drivers according to the info already in mapping database
956 // the less order number in mapping database the less order number in NvRamMap
957 //
958 for (Index=0; Index < SelectedDriverImageNum; Index++) {
959 //
960 // Find the minimal order number in TempNO array, its index in TempNO is same as IfrOptionList array
961 //
962 MinNO = 0;
963 for (Index1=0; Index1 < SelectedDriverImageNum; Index1++) {
964 if (TempNO[Index1] < TempNO[MinNO]) {
965 MinNO = Index1;
966 }
967 }
968 //
969 // the IfrOptionList[MinNO].Value = the driver NO. in driver binding buffer
970 //
971 FakeNvData->DriOrder[Index] =IfrOptionList[MinNO].Value.u8;
972 TempNO[MinNO] = MAX_CHOICE_NUM + 1;
973 }
974
975 CreateOrderedListOpCode (
976 (UINT16) DRIVER_ORDER_QUESTION_ID,
977 VARSTORE_ID_PLAT_OVER_MNGR,
978 (UINT16) DRIVER_ORDER_VAR_OFFSET,
979 mControllerToken[mSelectedCtrIndex],
980 mControllerToken[mSelectedCtrIndex],
981 EFI_IFR_FLAG_RESET_REQUIRED,
982 0,
983 EFI_IFR_NUMERIC_SIZE_1,
984 (UINT8) MAX_CHOICE_NUM,
985 IfrOptionList,
986 SelectedDriverImageNum,
987 &UpdateData
988 );
989
990 //
991 // Update third page form
992 //
993 IfrLibUpdateForm (
994 Private->RegisteredHandle,
995 &mPlatformOverridesManagerGuid,
996 FORM_ID_ORDER,
997 FORM_ID_ORDER,
998 FALSE,
999 &UpdateData
1000 );
1001
1002 FreePool (IfrOptionList);
1003 FreePool (UpdateData.Data);
1004 return EFI_SUCCESS;
1005 }
1006
1007 /**
1008 Save the save the mapping database to NV variable.
1009
1010 @param Private Pointer to EFI_CALLBACK_INFO.
1011 @param KeyValue The callback key value of device controller item in first page.
1012 @param FakeNvData Pointer to PLAT_OVER_MNGR_DATA.
1013
1014 @retval EFI_SUCCESS Always returned.
1015
1016 **/
1017 EFI_STATUS
1018 CommintChanges (
1019 IN EFI_CALLBACK_INFO *Private,
1020 IN UINT16 KeyValue,
1021 IN PLAT_OVER_MNGR_DATA *FakeNvData
1022 )
1023 {
1024 EFI_STATUS Status;
1025 UINTN Index;
1026 UINTN SelectedDriverImageNum;
1027 EFI_DEVICE_PATH_PROTOCOL *LoadedImageDevicePath;
1028 //
1029 // Following code will be run if user select 'commint changes' in third page
1030 // user enter 'Commit Changes' to save the mapping database
1031 //
1032 ASSERT (mSelectedCtrIndex < MAX_CHOICE_NUM);
1033 DeleteDriverImage (mControllerDevicePathProtocol[mSelectedCtrIndex], NULL, &mMappingDataBase);
1034 for (SelectedDriverImageNum = 0; SelectedDriverImageNum < mSelectedDriverImageNum; SelectedDriverImageNum++) {
1035 //
1036 // DriOrder[SelectedDriverImageNum] = the driver NO. in driver binding buffer
1037 //
1038 Index = FakeNvData->DriOrder[SelectedDriverImageNum] - 1;
1039
1040 //
1041 // Get the EFI Loaded Image Device Path Protocol
1042 //
1043 LoadedImageDevicePath = NULL;
1044 Status = gBS->HandleProtocol (
1045 mDriverImageHandleBuffer[Index],
1046 &gEfiLoadedImageDevicePathProtocolGuid,
1047 (VOID **) &LoadedImageDevicePath
1048 );
1049 ASSERT (LoadedImageDevicePath != NULL);
1050
1051 InsertDriverImage (
1052 mControllerDevicePathProtocol[mSelectedCtrIndex],
1053 LoadedImageDevicePath,
1054 &mMappingDataBase,
1055 (UINT32)SelectedDriverImageNum + 1
1056 );
1057 }
1058 Status = SaveOverridesMapping (&mMappingDataBase);
1059
1060 return Status;
1061 }
1062
1063 /**
1064 This function allows a caller to extract the current configuration for one
1065 or more named elements from the target driver.
1066
1067 @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
1068 @param Request A null-terminated Unicode string in <ConfigRequest> format.
1069 @param Progress On return, points to a character in the Request string.
1070 Points to the string's null terminator if request was successful.
1071 Points to the most recent '&' before the first failing name/value
1072 pair (or the beginning of the string if the failure is in the
1073 first name/value pair) if the request was not successful.
1074 @param Results A null-terminated Unicode string in <ConfigAltResp> format which
1075 has all values filled in for the names in the Request string.
1076 String to be allocated by the called function.
1077
1078 @retval EFI_SUCCESS The Results is filled with the requested values.
1079 @retval EFI_OUT_OF_RESOURCES Not enough memory to store the results.
1080 @retval EFI_INVALID_PARAMETER Request is NULL, illegal syntax, or unknown name.
1081 @retval EFI_NOT_FOUND Routing data doesn't match any storage in this driver.
1082
1083 **/
1084 EFI_STATUS
1085 EFIAPI
1086 PlatOverMngrExtractConfig (
1087 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
1088 IN CONST EFI_STRING Request,
1089 OUT EFI_STRING *Progress,
1090 OUT EFI_STRING *Results
1091 )
1092 {
1093 EFI_STATUS Status;
1094 EFI_CALLBACK_INFO *Private;
1095 EFI_HII_CONFIG_ROUTING_PROTOCOL *HiiConfigRouting;
1096
1097 if (Request == NULL) {
1098 return EFI_NOT_FOUND;
1099 }
1100
1101 Private = EFI_CALLBACK_INFO_FROM_THIS (This);
1102 HiiConfigRouting = Private->HiiConfigRouting;
1103
1104 //
1105 // Convert buffer data to <ConfigResp> by helper function BlockToConfig()
1106 //
1107 Status = HiiConfigRouting->BlockToConfig (
1108 HiiConfigRouting,
1109 Request,
1110 (UINT8 *) &Private->FakeNvData,
1111 sizeof (PLAT_OVER_MNGR_DATA),
1112 Results,
1113 Progress
1114 );
1115 return Status;
1116 }
1117
1118 /**
1119 This function processes the results of changes in configuration.
1120
1121 @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
1122 @param Configuration A null-terminated Unicode string in <ConfigRequest> format.
1123 @param Progress A pointer to a string filled in with the offset of the most
1124 recent '&' before the first failing name/value pair (or the
1125 beginning of the string if the failure is in the first
1126 name/value pair) or the terminating NULL if all was successful.
1127
1128 @retval EFI_SUCCESS The Results is processed successfully.
1129 @retval EFI_INVALID_PARAMETER Configuration is NULL.
1130 @retval EFI_NOT_FOUND Routing data doesn't match any storage in this driver.
1131
1132 **/
1133 EFI_STATUS
1134 EFIAPI
1135 PlatOverMngrRouteConfig (
1136 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
1137 IN CONST EFI_STRING Configuration,
1138 OUT EFI_STRING *Progress
1139 )
1140 {
1141 EFI_CALLBACK_INFO *Private;
1142 EFI_STATUS Status;
1143 UINT16 KeyValue;
1144 UINTN BufferSize;
1145 PLAT_OVER_MNGR_DATA *FakeNvData;
1146
1147 Private = EFI_CALLBACK_INFO_FROM_THIS (This);
1148
1149 FakeNvData = &Private->FakeNvData;
1150 BufferSize = sizeof (PLAT_OVER_MNGR_DATA);
1151 Status = GetBrowserData (NULL, NULL, &BufferSize, (UINT8 *) FakeNvData);
1152 if (EFI_ERROR (Status)) {
1153 return Status;
1154 }
1155
1156 if (mCurrentPage == FORM_ID_DRIVER) {
1157 KeyValue = KEY_VALUE_DRIVER_GOTO_ORDER;
1158 UpdatePrioritySelectPage (Private, KeyValue, FakeNvData);
1159 KeyValue = KEY_VALUE_ORDER_SAVE_AND_EXIT;
1160 CommintChanges (Private, KeyValue, FakeNvData);
1161 //
1162 // Since UpdatePrioritySelectPage will change mCurrentPage,
1163 // should ensure the mCurrentPage still indicate the second page here
1164 //
1165 mCurrentPage = FORM_ID_DRIVER;
1166 }
1167
1168 if (mCurrentPage == FORM_ID_ORDER) {
1169 KeyValue = KEY_VALUE_ORDER_SAVE_AND_EXIT;
1170 CommintChanges (Private, KeyValue, FakeNvData);
1171 }
1172 return EFI_SUCCESS;
1173 }
1174
1175 /**
1176 This is the function that is called to provide results data to the driver. This data
1177 consists of a unique key which is used to identify what data is either being passed back
1178 or being asked for.
1179
1180 @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
1181 @param Action A null-terminated Unicode string in <ConfigRequest> format.
1182 @param KeyValue A unique Goto OpCode callback value which record user's selection.
1183 0x100 <= KeyValue <0x500 : user select a controller item in the first page;
1184 KeyValue == 0x1234 : user select 'Refresh' in first page, or user select 'Go to Previous Menu' in second page
1185 KeyValue == 0x1235 : user select 'Pci device filter' in first page
1186 KeyValue == 0x1500 : user select 'order ... priority' item in second page
1187 KeyValue == 0x1800 : user select 'commint changes' in third page
1188 KeyValue == 0x2000 : user select 'Go to Previous Menu' in third page
1189 @param Type The type of value for the question.
1190 @param Value A pointer to the data being sent to the original exporting driver.
1191 @param ActionRequest On return, points to the action requested by the callback function.
1192
1193 @retval EFI_SUCCESS Always returned.
1194
1195 **/
1196 EFI_STATUS
1197 EFIAPI
1198 PlatOverMngrCallback (
1199 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
1200 IN EFI_BROWSER_ACTION Action,
1201 IN EFI_QUESTION_ID KeyValue,
1202 IN UINT8 Type,
1203 IN EFI_IFR_TYPE_VALUE *Value,
1204 OUT EFI_BROWSER_ACTION_REQUEST *ActionRequest
1205 )
1206 {
1207 EFI_CALLBACK_INFO *Private;
1208 EFI_STATUS Status;
1209 EFI_STRING_ID NewStringToken;
1210 UINTN BufferSize;
1211 PLAT_OVER_MNGR_DATA *FakeNvData;
1212 EFI_INPUT_KEY Key;
1213
1214 Private = EFI_CALLBACK_INFO_FROM_THIS (This);
1215
1216 FakeNvData = &Private->FakeNvData;
1217 BufferSize = sizeof (PLAT_OVER_MNGR_DATA);
1218 Status = GetBrowserData (NULL, NULL, &BufferSize, (UINT8 *) FakeNvData);
1219 if (EFI_ERROR (Status)) {
1220 return Status;
1221 }
1222
1223 if (KeyValue == KEY_VALUE_DEVICE_REFRESH ||
1224 KeyValue == KEY_VALUE_DEVICE_FILTER ||
1225 KeyValue == KEY_VALUE_DRIVER_GOTO_PREVIOUS
1226 ) {
1227 UpdateDeviceSelectPage (Private, KeyValue, FakeNvData);
1228 //
1229 // Update page title string
1230 //
1231 NewStringToken = STRING_TOKEN (STR_TITLE);
1232 Status = HiiLibSetString (Private->RegisteredHandle, NewStringToken, L"First, Select the controller by device path");
1233 ASSERT_EFI_ERROR (Status);
1234 }
1235
1236 if (((KeyValue >= KEY_VALUE_DEVICE_OFFSET) && (KeyValue < KEY_VALUE_DEVICE_MAX)) || (KeyValue == KEY_VALUE_ORDER_GOTO_PREVIOUS)) {
1237 if (KeyValue == KEY_VALUE_ORDER_GOTO_PREVIOUS) {
1238 KeyValue = (EFI_QUESTION_ID) (mSelectedCtrIndex + KEY_VALUE_DEVICE_OFFSET);
1239 }
1240 UpdateBindingDriverSelectPage (Private, KeyValue, FakeNvData);
1241 //
1242 // Update page title string
1243 //
1244 NewStringToken = STRING_TOKEN (STR_TITLE);
1245 Status = HiiLibSetString (Private->RegisteredHandle, NewStringToken, L"Second, Select drivers for the previous selected controller");
1246 ASSERT_EFI_ERROR (Status);
1247 }
1248
1249 if (KeyValue == KEY_VALUE_DRIVER_GOTO_ORDER) {
1250 UpdatePrioritySelectPage (Private, KeyValue, FakeNvData);
1251 //
1252 // Update page title string
1253 //
1254 NewStringToken = STRING_TOKEN (STR_TITLE);
1255 Status = HiiLibSetString (Private->RegisteredHandle, NewStringToken, L"Finally, Set the priority order for the drivers and save them");
1256 ASSERT_EFI_ERROR (Status);
1257 }
1258
1259 if (KeyValue == KEY_VALUE_ORDER_SAVE_AND_EXIT) {
1260 Status = CommintChanges (Private, KeyValue, FakeNvData);
1261 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_SUBMIT;
1262 if (EFI_ERROR (Status)) {
1263 IfrLibCreatePopUp (1, &Key, L"Single Override Info too large, Saving Error!");
1264 return EFI_DEVICE_ERROR;
1265 }
1266 }
1267
1268 if (KeyValue == KEY_VALUE_DEVICE_CLEAR) {
1269 //
1270 // Deletes all environment variable(s) that contain the override mappings info
1271 //
1272 FreeMappingDatabase (&mMappingDataBase);
1273 Status = SaveOverridesMapping (&mMappingDataBase);
1274 UpdateDeviceSelectPage (Private, KeyValue, FakeNvData);
1275 }
1276 //
1277 // Pass changed uncommitted data back to Form Browser
1278 //
1279 BufferSize = sizeof (PLAT_OVER_MNGR_DATA);
1280 Status = SetBrowserData (NULL, NULL, BufferSize, (UINT8 *) FakeNvData, NULL);
1281
1282 return EFI_SUCCESS;
1283 }
1284
1285 /**
1286 The driver Entry Point. The funciton will export a disk device class formset and
1287 its callback function to hii database.
1288
1289 @param ImageHandle The firmware allocated handle for the EFI image.
1290 @param SystemTable A pointer to the EFI System Table.
1291
1292 @retval EFI_SUCCESS The entry point is executed successfully.
1293 @retval other Some error occurs when executing this entry point.
1294
1295 **/
1296 EFI_STATUS
1297 EFIAPI
1298 PlatOverMngrInit (
1299 IN EFI_HANDLE ImageHandle,
1300 IN EFI_SYSTEM_TABLE *SystemTable
1301 )
1302 {
1303 EFI_STATUS Status;
1304 EFI_HII_DATABASE_PROTOCOL *HiiDatabase;
1305 EFI_HII_PACKAGE_LIST_HEADER *PackageList;
1306 EFI_CALLBACK_INFO *CallbackInfo;
1307 EFI_HANDLE DriverHandle;
1308 EFI_FORM_BROWSER2_PROTOCOL *FormBrowser2;
1309
1310 //
1311 // There should only be one HII protocol
1312 //
1313 Status = gBS->LocateProtocol (
1314 &gEfiHiiDatabaseProtocolGuid,
1315 NULL,
1316 (VOID **) &HiiDatabase
1317 );
1318 if (EFI_ERROR (Status)) {
1319 return Status;
1320 }
1321
1322 //
1323 // There should only be one Form Configuration protocol
1324 //
1325 Status = gBS->LocateProtocol (
1326 &gEfiFormBrowser2ProtocolGuid,
1327 NULL,
1328 (VOID **) &FormBrowser2
1329 );
1330 if (EFI_ERROR (Status)) {
1331 return Status;
1332 }
1333
1334 CallbackInfo = AllocateZeroPool (sizeof (EFI_CALLBACK_INFO));
1335 if (CallbackInfo == NULL) {
1336 return EFI_BAD_BUFFER_SIZE;
1337 }
1338
1339 CallbackInfo->Signature = EFI_CALLBACK_INFO_SIGNATURE;
1340 CallbackInfo->ConfigAccess.ExtractConfig = PlatOverMngrExtractConfig;
1341 CallbackInfo->ConfigAccess.RouteConfig = PlatOverMngrRouteConfig;
1342 CallbackInfo->ConfigAccess.Callback = PlatOverMngrCallback;
1343
1344 //
1345 // Create driver handle used by HII database
1346 //
1347 Status = HiiLibCreateHiiDriverHandle (&DriverHandle);
1348 if (EFI_ERROR (Status)) {
1349 goto Finish;
1350 }
1351 CallbackInfo->DriverHandle = DriverHandle;
1352
1353 //
1354 // Install Config Access protocol to driver handle
1355 //
1356 Status = gBS->InstallProtocolInterface (
1357 &DriverHandle,
1358 &gEfiHiiConfigAccessProtocolGuid,
1359 EFI_NATIVE_INTERFACE,
1360 &CallbackInfo->ConfigAccess
1361 );
1362 if (EFI_ERROR (Status)) {
1363 goto Finish;
1364 }
1365
1366 //
1367 // Publish our HII data
1368 //
1369 PackageList = HiiLibPreparePackageList (
1370 2,
1371 &mPlatformOverridesManagerGuid,
1372 VfrBin,
1373 PlatOverMngrStrings
1374 );
1375 ASSERT (PackageList != NULL);
1376
1377 Status = HiiDatabase->NewPackageList (
1378 HiiDatabase,
1379 PackageList,
1380 DriverHandle,
1381 &CallbackInfo->RegisteredHandle
1382 );
1383 FreePool (PackageList);
1384
1385 if (EFI_ERROR (Status)) {
1386 goto Finish;
1387 }
1388
1389 //
1390 // Locate ConfigRouting protocol
1391 //
1392 Status = gBS->LocateProtocol (
1393 &gEfiHiiConfigRoutingProtocolGuid,
1394 NULL,
1395 (VOID **) &CallbackInfo->HiiConfigRouting
1396 );
1397 if (EFI_ERROR (Status)) {
1398 goto Finish;
1399 }
1400
1401 //
1402 // Clear all the globle variable
1403 //
1404 mDriverImageHandleCount = 0;
1405 mCurrentPage = 0;
1406 ZeroMem (mDriverImageToken, MAX_CHOICE_NUM * sizeof (EFI_STRING_ID));
1407 ZeroMem (mDriverImageFilePathToken, MAX_CHOICE_NUM * sizeof (EFI_STRING_ID));
1408 ZeroMem (mControllerToken, MAX_CHOICE_NUM * sizeof (EFI_STRING_ID));
1409 ZeroMem (mDriverImageProtocol, MAX_CHOICE_NUM * sizeof (EFI_LOADED_IMAGE_PROTOCOL *));
1410
1411 //
1412 // Show the page
1413 //
1414 Status = FormBrowser2->SendForm (
1415 FormBrowser2,
1416 &CallbackInfo->RegisteredHandle,
1417 1,
1418 NULL,
1419 0,
1420 NULL,
1421 NULL
1422 );
1423 if (EFI_ERROR (Status)) {
1424 goto Finish;
1425 }
1426
1427 Status = HiiDatabase->RemovePackageList (HiiDatabase, CallbackInfo->RegisteredHandle);
1428 if (EFI_ERROR (Status)) {
1429 goto Finish;
1430 }
1431
1432 return EFI_SUCCESS;
1433
1434 Finish:
1435 if (CallbackInfo->DriverHandle != NULL) {
1436 HiiLibDestroyHiiDriverHandle (CallbackInfo->DriverHandle);
1437 }
1438 if (CallbackInfo != NULL) {
1439 FreePool (CallbackInfo);
1440 }
1441
1442 return Status;
1443 }
EFI Development Kit II mirror for PVE