]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Universal/PlatformDriverOverride/PlatOverMngr/PlatOverMngr.c
projects / mirror_edk2.git / blob
? search:


e4ea60cff2ad75457a066fdaec47606455562d6d
[mirror_edk2.git] / MdeModulePkg / Universal / PlatformDriverOverride / PlatOverMngr / PlatOverMngr.c
1 /** @file
2
3 Copyright (c) 2007 - 2008, Intel Corporation
4 All rights reserved. This program and the accompanying materials
5 are licensed and made available under the terms and conditions of the BSD License
6 which accompanies this distribution. The full text of the license may be found at
7 http://opensource.org/licenses/bsd-license.php
8
9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
11
12 Module Name:
13
14 PlatOverMngr.c
15
16 Abstract:
17
18 A UI application to offer a UI interface in device manager to let user configue
19 platform override protocol to override the default algorithm for matching
20 drivers to controllers.
21
22 The main flow:
23 1. The UI application dynamicly locate all controller device path.
24 2. The UI application dynamicly locate all drivers which support binding protocol.
25 3. The UI application export and dynamicly update two menu to let user select the
26 mapping between drivers to controllers.
27 4. The UI application save all the mapping info in NV variables which will be consumed
28 by platform override protocol driver to publish the platform override protocol.
29
30 **/
31
32 #include <PiDxe.h>
33
34 #include <Protocol/HiiConfigAccess.h>
35 #include <Protocol/HiiConfigRouting.h>
36 #include <Protocol/HiiDatabase.h>
37 #include <Protocol/FormBrowser2.h>
38 #include <Protocol/LoadedImage.h>
39 #include <Protocol/FirmwareVolume2.h>
40 #include <Protocol/PciIo.h>
41 #include <Protocol/BusSpecificDriverOverride.h>
42 #include <Protocol/ComponentName2.h>
43 #include <Protocol/ComponentName.h>
44 #include <Protocol/DriverBinding.h>
45
46 #include <Library/BaseLib.h>
47 #include <Library/DebugLib.h>
48 #include <Library/UefiLib.h>
49 #include <Library/UefiApplicationEntryPoint.h>
50 #include <Library/UefiBootServicesTableLib.h>
51 #include <Library/PlatDriOverLib.h>
52 #include <Library/HiiLib.h>
53 #include <Library/IfrSupportLib.h>
54 #include <Library/ExtendedHiiLib.h>
55 #include <Library/ExtendedIfrSupportLib.h>
56 #include <Library/BaseMemoryLib.h>
57 #include <Library/MemoryAllocationLib.h>
58 #include <Library/UefiRuntimeServicesTableLib.h>
59 #include <Library/DevicePathLib.h>
60 #include <Library/GenericBdsLib.h>
61 #include "PlatOverMngr.h"
62
63 #define EFI_CALLBACK_INFO_SIGNATURE SIGNATURE_32 ('C', 'l', 'b', 'k')
64 #define EFI_CALLBACK_INFO_FROM_THIS(a) CR (a, EFI_CALLBACK_INFO, ConfigAccess, EFI_CALLBACK_INFO_SIGNATURE)
65
66 typedef struct {
67 UINTN Signature;
68 EFI_HANDLE DriverHandle;
69 EFI_HII_HANDLE RegisteredHandle;
70 PLAT_OVER_MNGR_DATA FakeNvData;
71 EFI_HII_CONFIG_ROUTING_PROTOCOL *HiiConfigRouting;
72 EFI_HII_CONFIG_ACCESS_PROTOCOL ConfigAccess;
73 } EFI_CALLBACK_INFO;
74
75 //
76 // uni string and Vfr Binary data.
77 //
78 extern UINT8 VfrBin[];
79 extern UINT8 PlatOverMngrStrings[];
80
81 //
82 // module global data
83 //
84 EFI_GUID mPlatformOverridesManagerGuid = PLAT_OVER_MNGR_GUID;
85 LIST_ENTRY mMappingDataBase = INITIALIZE_LIST_HEAD_VARIABLE (mMappingDataBase);
86
87 EFI_HANDLE *mDevicePathHandleBuffer;
88 EFI_HANDLE *mDriverImageHandleBuffer;
89
90 UINTN mSelectedCtrIndex;
91 EFI_STRING_ID mControllerToken[MAX_CHOICE_NUM];
92 UINTN mDriverImageHandleCount;
93 EFI_STRING_ID mDriverImageToken[MAX_CHOICE_NUM];
94 EFI_STRING_ID mDriverImageFilePathToken[MAX_CHOICE_NUM];
95 EFI_LOADED_IMAGE_PROTOCOL *mDriverImageProtocol[MAX_CHOICE_NUM];
96 EFI_DEVICE_PATH_PROTOCOL *mControllerDevicePathProtocol[MAX_CHOICE_NUM];
97 UINTN mSelectedDriverImageNum;
98 UINTN mLastSavedDriverImageNum;
99 CHAR8 mLanguage[RFC_3066_ENTRY_SIZE];
100 UINT16 mCurrentPage;
101
102 /**
103 Do string convertion for the ComponentName supported language. It do
104 the convertion just for english language code from RFC 3066 to ISO 639-2.
105 Then it will check whether the converted language is in the supported language list.
106 If not supported, NULL is returned.
107 If Language is not english, NULL is returned.
108
109 @param SupportedLanguages Pointer to ComponentName supported language string list. ISO 639-2 language
110 @param Language The language string. RFC 3066 language
111
112 @return English language string (ISO 639-2)
113 @return NULL if the conertion is not successful.
114
115 **/
116 CHAR8 *
117 ConvertComponentNameSupportLanguage (
118 IN CHAR8 *SupportedLanguages,
119 IN CHAR8 *Language
120 )
121 {
122 CHAR8 *LangCode;
123 LangCode = NULL;
124
125 //
126 // check the input language is English
127 //
128 if (AsciiStrnCmp (Language, "en-", 3) != 0) {
129 return NULL;
130 }
131
132 //
133 // Convert Language string from RFC 3066 to ISO 639-2
134 //
135 LangCode = AllocateZeroPool(4);
136 AsciiStrCpy (LangCode, "eng");
137
138 //
139 // Check whether the converted language is supported in the SupportedLanguages list.
140 //
141 if (AsciiStrStr (SupportedLanguages, LangCode) == NULL) {
142 FreePool (LangCode);
143 return NULL;
144 }
145
146 return LangCode;
147 }
148
149 /**
150 Get the driver name by ComponentName or ComponentName2 protocol
151 according to the driver binding handle
152
153 @param DriverBindingHandle The Handle of DriverBinding.
154
155 @retval !NULL Pointer into the image name if the image name is found,
156 @retval NULL Pointer to NULL if the image name is not found.
157
158 **/
159 CHAR16 *
160 GetComponentName (
161 IN EFI_HANDLE DriverBindingHandle
162 )
163 {
164 EFI_STATUS Status;
165 EFI_COMPONENT_NAME_PROTOCOL *ComponentName;
166 EFI_COMPONENT_NAME2_PROTOCOL *ComponentName2;
167 CHAR8 *SupportedLanguage;
168 CHAR16 *DriverName;
169
170 ComponentName = NULL;
171 ComponentName2 = NULL;
172 Status = gBS->OpenProtocol (
173 DriverBindingHandle,
174 &gEfiComponentName2ProtocolGuid,
175 (VOID **) &ComponentName2,
176 NULL,
177 NULL,
178 EFI_OPEN_PROTOCOL_GET_PROTOCOL
179 );
180 if (EFI_ERROR(Status)) {
181 Status = gBS->OpenProtocol (
182 DriverBindingHandle,
183 &gEfiComponentNameProtocolGuid,
184 (VOID **) &ComponentName,
185 NULL,
186 NULL,
187 EFI_OPEN_PROTOCOL_GET_PROTOCOL
188 );
189 }
190
191 Status = EFI_SUCCESS;
192 DriverName = NULL;
193 if (ComponentName != NULL) {
194 if (ComponentName->GetDriverName != NULL) {
195 SupportedLanguage = ConvertComponentNameSupportLanguage (ComponentName->SupportedLanguages, mLanguage);
196 Status = ComponentName->GetDriverName (
197 ComponentName,
198 SupportedLanguage,
199 &DriverName
200 );
201 FreePool (SupportedLanguage);
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 for (Index = 0; Index < DriverBindingHandleCount; Index++) {
560 DriverBindingInterface = NULL;
561 Status = gBS->OpenProtocol (
562 DriverBindingHandleBuffer[Index],
563 &gEfiDriverBindingProtocolGuid,
564 (VOID **) &DriverBindingInterface,
565 NULL,
566 NULL,
567 EFI_OPEN_PROTOCOL_GET_PROTOCOL
568 );
569 if (EFI_ERROR (Status)) {
570 continue;
571 }
572
573 if (DriverBindingInterface->ImageHandle == ImageHandle) {
574 DriverBindingHandle = DriverBindingHandleBuffer[Index];
575 break;
576 }
577 }
578
579 //
580 // If no Driver Binding Protocol instance is found
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 @param FakeNvData Pointer to PLAT_OVER_MNGR_DATA.
593
594 @retval EFI_SUCCESS Always returned.
595
596 **/
597 EFI_STATUS
598 UpdateBindingDriverSelectPage (
599 IN EFI_CALLBACK_INFO *Private,
600 IN UINT16 KeyValue,
601 IN PLAT_OVER_MNGR_DATA *FakeNvData
602 )
603 {
604 EFI_HII_UPDATE_DATA UpdateData;
605 EFI_STATUS Status;
606 UINTN Index;
607 CHAR16 *NewString;
608 EFI_STRING_ID NewStringToken;
609 EFI_STRING_ID NewStringHelpToken;
610 UINTN DriverImageHandleCount;
611 EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
612 CHAR16 *DriverName;
613 BOOLEAN FreeDriverName;
614 EFI_DEVICE_PATH_PROTOCOL *LoadedImageDevicePath;
615 EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL *BusSpecificDriverOverride;
616 EFI_HANDLE DriverBindingHandle;
617
618 //
619 // If user select a controller item in the first page the following code will be run.
620 // During second page, user will see all currnet driver bind protocol driver, the driver name and its device path will be shown
621 //
622 //First acquire the list of Loaded Image Protocols, and then when want the name of the driver, look up all the Driver Binding Protocols
623 // and find the first one whose ImageHandle field matches the image handle of the Loaded Image Protocol.
624 // 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.
625 //
626
627 mCurrentPage = FORM_ID_DRIVER;
628 //
629 // Switch the item callback key value to its NO. in mDevicePathHandleBuffer
630 //
631 mSelectedCtrIndex = KeyValue - KEY_VALUE_DEVICE_OFFSET;
632 ASSERT (mSelectedCtrIndex < MAX_CHOICE_NUM);
633 mLastSavedDriverImageNum = 0;
634 //
635 // Clear all the content in dynamic page
636 //
637 UpdateData.BufferSize = UPDATE_DATA_SIZE;
638 UpdateData.Offset = 0;
639 UpdateData.Data = AllocateZeroPool (UPDATE_DATA_SIZE);
640 ASSERT (UpdateData.Data != NULL);
641 //
642 // Clear second page form
643 //
644 IfrLibUpdateForm (
645 Private->RegisteredHandle,
646 &mPlatformOverridesManagerGuid,
647 FORM_ID_DRIVER,
648 FORM_ID_DRIVER,
649 FALSE,
650 &UpdateData
651 );
652
653 //
654 // Show all driver which support loaded image protocol in second page
655 //
656 DriverImageHandleCount = 0;
657 Status = gBS->LocateHandleBuffer (
658 ByProtocol,
659 &gEfiLoadedImageProtocolGuid,
660 NULL,
661 &DriverImageHandleCount,
662 &mDriverImageHandleBuffer
663 );
664 if (EFI_ERROR (Status) || (DriverImageHandleCount == 0)) {
665 return EFI_NOT_FOUND;
666 }
667
668 mDriverImageHandleCount = DriverImageHandleCount;
669 for (Index = 0; Index < DriverImageHandleCount; Index++) {
670 //
671 // Step1: Get the driver image total file path for help string and the driver name.
672 //
673
674 //
675 // Find driver's Loaded Image protocol
676 //
677 LoadedImage =NULL;
678
679 Status = gBS->OpenProtocol (
680 mDriverImageHandleBuffer[Index],
681 &gEfiLoadedImageProtocolGuid,
682 (VOID **) &LoadedImage,
683 NULL,
684 NULL,
685 EFI_OPEN_PROTOCOL_GET_PROTOCOL
686 );
687 if (EFI_ERROR (Status)) {
688 FakeNvData->DriSelection[Index] = 0x00;
689 continue;
690 }
691 mDriverImageProtocol[Index] = LoadedImage;
692 //
693 // Find its related driver binding protocol
694 //
695 DriverBindingHandle = GetDriverBindingHandleFromImageHandle (mDriverImageHandleBuffer[Index]);
696 if (DriverBindingHandle == NULL) {
697 FakeNvData->DriSelection[Index] = 0x00;
698 continue;
699 }
700
701 //
702 // Get the EFI Loaded Image Device Path Protocol
703 //
704 LoadedImageDevicePath = NULL;
705 Status = gBS->HandleProtocol (
706 mDriverImageHandleBuffer[Index],
707 &gEfiLoadedImageDevicePathProtocolGuid,
708 (VOID **) &LoadedImageDevicePath
709 );
710 if (LoadedImageDevicePath == NULL) {
711 FakeNvData->DriSelection[Index] = 0x00;
712 continue;
713 }
714
715 if (FakeNvData->PciDeviceFilter == 0x01) {
716 //
717 // only care the driver which is in a Pci device option rom,
718 // and the driver's LoadedImage->DeviceHandle must point to a pci device which has efi option rom
719 //
720 if (!EFI_ERROR (Status)) {
721 Status = gBS->HandleProtocol(
722 LoadedImage->DeviceHandle,
723 &gEfiBusSpecificDriverOverrideProtocolGuid,
724 (VOID **) &BusSpecificDriverOverride
725 );
726 if (EFI_ERROR (Status) || BusSpecificDriverOverride == NULL) {
727 FakeNvData->DriSelection[Index] = 0x00;
728 continue;
729 }
730 } else {
731 FakeNvData->DriSelection[Index] = 0x00;
732 continue;
733 }
734 }
735
736 //
737 // For driver name, try to get its component name, if fail, get its image name,
738 // if also fail, give a default name.
739 //
740 FreeDriverName = FALSE;
741 DriverName = GetComponentName (DriverBindingHandle);
742 if (DriverName == NULL) {
743 //
744 // get its image name
745 //
746 DriverName = GetImageName (LoadedImage);
747 }
748 if (DriverName == NULL) {
749 //
750 // give a default name
751 //
752 HiiLibGetStringFromHandle (Private->RegisteredHandle, STRING_TOKEN (STR_DRIVER_DEFAULT_NAME), &DriverName);
753 ASSERT (DriverName != NULL);
754 FreeDriverName = TRUE; // the DriverName string need to free pool
755 }
756
757
758 //
759 // Step2 Export the driver name string and create check box item in second page
760 //
761
762 //
763 // First create the driver image name
764 //
765 NewString = AllocateZeroPool (StrSize (DriverName));
766 ASSERT (NewString != NULL);
767 if (EFI_ERROR (CheckMapping (mControllerDevicePathProtocol[mSelectedCtrIndex], LoadedImageDevicePath, &mMappingDataBase, NULL, NULL))) {
768 FakeNvData->DriSelection[Index] = 0x00;
769 } else {
770 FakeNvData->DriSelection[Index] = 0x01;
771 mLastSavedDriverImageNum++;
772 }
773 StrCat (NewString, DriverName);
774 NewStringToken = mDriverImageToken[Index];
775 if (NewStringToken == 0) {
776 Status = HiiLibNewString (Private->RegisteredHandle, &NewStringToken, NewString);
777 } else {
778 Status = HiiLibSetString (Private->RegisteredHandle, NewStringToken, NewString);
779 }
780 mDriverImageToken[Index] = NewStringToken;
781 ASSERT_EFI_ERROR (Status);
782 FreePool (NewString);
783 if (FreeDriverName) {
784 FreePool (DriverName);
785 }
786
787 //
788 // Second create the driver image device path as item help string
789 //
790 DriverName = DevicePathToStr (LoadedImageDevicePath);
791
792 NewString = AllocateZeroPool (StrSize (DriverName));
793 StrCat (NewString, DriverName);
794 NewStringHelpToken = mDriverImageFilePathToken[Index];
795 if (NewStringHelpToken == 0) {
796 Status = HiiLibNewString (Private->RegisteredHandle, &NewStringHelpToken, NewString);
797 } else {
798 Status = HiiLibSetString (Private->RegisteredHandle, NewStringHelpToken, NewString);
799 }
800 mDriverImageFilePathToken[Index] = NewStringHelpToken;
801 ASSERT_EFI_ERROR (Status);
802 FreePool (NewString);
803 FreePool (DriverName);
804
805 CreateCheckBoxOpCode (
806 (UINT16) (DRIVER_SELECTION_QUESTION_ID + Index),
807 VARSTORE_ID_PLAT_OVER_MNGR,
808 (UINT16) (DRIVER_SELECTION_VAR_OFFSET + Index),
809 NewStringToken,
810 NewStringHelpToken,
811 0,
812 0,
813 &UpdateData
814 );
815 }
816
817 //
818 // Update second page form
819 //
820 IfrLibUpdateForm (
821 Private->RegisteredHandle,
822 &mPlatformOverridesManagerGuid,
823 FORM_ID_DRIVER,
824 FORM_ID_DRIVER,
825 FALSE,
826 &UpdateData
827 );
828
829 FreePool (UpdateData.Data);
830 return EFI_SUCCESS;
831 }
832
833 /**
834 Prepare to let user select the priority order of the drivers which are
835 selected in second page.
836
837 @param Private Pointer to EFI_CALLBACK_INFO.
838 @param KeyValue The callback key value of device controller item in first page.
839 @param FakeNvData Pointer to PLAT_OVER_MNGR_DATA.
840
841 @retval EFI_SUCCESS Always returned.
842
843 **/
844 EFI_STATUS
845 UpdatePrioritySelectPage (
846 IN EFI_CALLBACK_INFO *Private,
847 IN UINT16 KeyValue,
848 IN PLAT_OVER_MNGR_DATA *FakeNvData
849 )
850 {
851 EFI_HII_UPDATE_DATA UpdateData;
852 UINTN Index;
853 EFI_DEVICE_PATH_PROTOCOL *LoadedImageDevicePath;
854 IFR_OPTION *IfrOptionList;
855 UINTN SelectedDriverImageNum;
856 UINT32 DriverImageNO;
857 UINTN MinNO;
858 UINTN Index1;
859 UINTN TempNO[100];
860
861 //
862 // Following code will be run if user select 'order ... priority' item in second page
863 // Prepare third page. In third page, user will order the drivers priority which are selected in second page
864 //
865 mCurrentPage = FORM_ID_ORDER;
866
867 UpdateData.BufferSize = UPDATE_DATA_SIZE;
868 UpdateData.Offset = 0;
869 UpdateData.Data = AllocateZeroPool (UPDATE_DATA_SIZE);
870 ASSERT (UpdateData.Data != NULL);
871 //
872 // Clear third page form
873 //
874 IfrLibUpdateForm (
875 Private->RegisteredHandle,
876 &mPlatformOverridesManagerGuid,
877 FORM_ID_ORDER,
878 FORM_ID_ORDER,
879 FALSE,
880 &UpdateData
881 );
882
883 //
884 // Check how many drivers have been selected
885 //
886 SelectedDriverImageNum = 0;
887 for (Index = 0; Index < mDriverImageHandleCount; Index++) {
888 if (FakeNvData->DriSelection[Index] != 0) {
889 SelectedDriverImageNum ++;
890 }
891 }
892
893 mSelectedDriverImageNum = SelectedDriverImageNum;
894 if (SelectedDriverImageNum == 0) {
895 return EFI_SUCCESS;
896 }
897
898 IfrOptionList = AllocateZeroPool (sizeof (IFR_OPTION) * mSelectedDriverImageNum);
899 ASSERT (IfrOptionList != NULL);
900 //
901 // Create order list for those selected drivers
902 //
903 SelectedDriverImageNum = 0;
904 for (Index = 0; Index < mDriverImageHandleCount; Index++) {
905 if (FakeNvData->DriSelection[Index] != 0) {
906 IfrOptionList[SelectedDriverImageNum].StringToken = mDriverImageToken[Index];
907 //
908 // Use the NO. in driver binding buffer as value, will use it later
909 //
910 IfrOptionList[SelectedDriverImageNum].Value.u8 = (UINT8) (Index + 1);
911 IfrOptionList[SelectedDriverImageNum].Flags = 0;
912
913 //
914 // Get the EFI Loaded Image Device Path Protocol
915 //
916 LoadedImageDevicePath = NULL;
917 gBS->HandleProtocol (
918 mDriverImageHandleBuffer[Index],
919 &gEfiLoadedImageDevicePathProtocolGuid,
920 (VOID **) &LoadedImageDevicePath
921 );
922 ASSERT (LoadedImageDevicePath != NULL);
923
924 //
925 // Check the driver DriverImage's order number in mapping database
926 //
927 DriverImageNO = 0;
928 CheckMapping (
929 mControllerDevicePathProtocol[mSelectedCtrIndex],
930 LoadedImageDevicePath,
931 &mMappingDataBase,
932 NULL,
933 &DriverImageNO
934 );
935 if (DriverImageNO == 0) {
936 DriverImageNO = (UINT32) mLastSavedDriverImageNum + 1;
937 mLastSavedDriverImageNum++;
938 }
939 TempNO[SelectedDriverImageNum] = DriverImageNO;
940 SelectedDriverImageNum ++;
941 }
942 }
943
944 ASSERT (SelectedDriverImageNum == mSelectedDriverImageNum);
945 //
946 // NvRamMap Must be clear firstly
947 //
948 ZeroMem (FakeNvData->DriOrder, sizeof (FakeNvData->DriOrder));
949
950 //
951 // Order the selected drivers according to the info already in mapping database
952 // the less order number in mapping database the less order number in NvRamMap
953 //
954 for (Index=0; Index < SelectedDriverImageNum; Index++) {
955 //
956 // Find the minimal order number in TempNO array, its index in TempNO is same as IfrOptionList array
957 //
958 MinNO = 0;
959 for (Index1=0; Index1 < SelectedDriverImageNum; Index1++) {
960 if (TempNO[Index1] < TempNO[MinNO]) {
961 MinNO = Index1;
962 }
963 }
964 //
965 // the IfrOptionList[MinNO].Value = the driver NO. in driver binding buffer
966 //
967 FakeNvData->DriOrder[Index] =IfrOptionList[MinNO].Value.u8;
968 TempNO[MinNO] = MAX_CHOICE_NUM + 1;
969 }
970
971 CreateOrderedListOpCode (
972 (UINT16) DRIVER_ORDER_QUESTION_ID,
973 VARSTORE_ID_PLAT_OVER_MNGR,
974 (UINT16) DRIVER_ORDER_VAR_OFFSET,
975 mControllerToken[mSelectedCtrIndex],
976 mControllerToken[mSelectedCtrIndex],
977 EFI_IFR_FLAG_RESET_REQUIRED,
978 0,
979 EFI_IFR_NUMERIC_SIZE_1,
980 (UINT8) MAX_CHOICE_NUM,
981 IfrOptionList,
982 SelectedDriverImageNum,
983 &UpdateData
984 );
985
986 //
987 // Update third page form
988 //
989 IfrLibUpdateForm (
990 Private->RegisteredHandle,
991 &mPlatformOverridesManagerGuid,
992 FORM_ID_ORDER,
993 FORM_ID_ORDER,
994 FALSE,
995 &UpdateData
996 );
997
998 FreePool (IfrOptionList);
999 FreePool (UpdateData.Data);
1000 return EFI_SUCCESS;
1001 }
1002
1003 /**
1004 Save the save the mapping database to NV variable.
1005
1006 @param Private Pointer to EFI_CALLBACK_INFO.
1007 @param KeyValue The callback key value of device controller item in first page.
1008 @param FakeNvData Pointer to PLAT_OVER_MNGR_DATA.
1009
1010 @retval EFI_SUCCESS Always returned.
1011
1012 **/
1013 EFI_STATUS
1014 CommintChanges (
1015 IN EFI_CALLBACK_INFO *Private,
1016 IN UINT16 KeyValue,
1017 IN PLAT_OVER_MNGR_DATA *FakeNvData
1018 )
1019 {
1020 EFI_STATUS Status;
1021 UINTN Index;
1022 UINTN SelectedDriverImageNum;
1023 EFI_DEVICE_PATH_PROTOCOL *LoadedImageDevicePath;
1024 //
1025 // Following code will be run if user select 'commint changes' in third page
1026 // user enter 'Commit Changes' to save the mapping database
1027 //
1028 DeleteDriverImage (mControllerDevicePathProtocol[mSelectedCtrIndex], NULL, &mMappingDataBase);
1029 for (SelectedDriverImageNum = 0; SelectedDriverImageNum < mSelectedDriverImageNum; SelectedDriverImageNum++) {
1030 //
1031 // DriOrder[SelectedDriverImageNum] = the driver NO. in driver binding buffer
1032 //
1033 Index = FakeNvData->DriOrder[SelectedDriverImageNum] - 1;
1034
1035 //
1036 // Get the EFI Loaded Image Device Path Protocol
1037 //
1038 LoadedImageDevicePath = NULL;
1039 Status = gBS->HandleProtocol (
1040 mDriverImageHandleBuffer[Index],
1041 &gEfiLoadedImageDevicePathProtocolGuid,
1042 (VOID **) &LoadedImageDevicePath
1043 );
1044 ASSERT (LoadedImageDevicePath != NULL);
1045
1046 InsertDriverImage (
1047 mControllerDevicePathProtocol[mSelectedCtrIndex],
1048 LoadedImageDevicePath,
1049 &mMappingDataBase,
1050 (UINT32)SelectedDriverImageNum + 1
1051 );
1052 }
1053 Status = SaveOverridesMapping (&mMappingDataBase);
1054
1055 return Status;
1056 }
1057
1058 /**
1059 This function allows a caller to extract the current configuration for one
1060 or more named elements from the target driver.
1061
1062 @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
1063 @param Request A null-terminated Unicode string in <ConfigRequest> format.
1064 @param Progress On return, points to a character in the Request string.
1065 Points to the string's null terminator if request was successful.
1066 Points to the most recent '&' before the first failing name/value
1067 pair (or the beginning of the string if the failure is in the
1068 first name/value pair) if the request was not successful.
1069 @param Results A null-terminated Unicode string in <ConfigAltResp> format which
1070 has all values filled in for the names in the Request string.
1071 String to be allocated by the called function.
1072
1073 @retval EFI_SUCCESS The Results is filled with the requested values.
1074 @retval EFI_OUT_OF_RESOURCES Not enough memory to store the results.
1075 @retval EFI_INVALID_PARAMETER Request is NULL, illegal syntax, or unknown name.
1076 @retval EFI_NOT_FOUND Routing data doesn't match any storage in this driver.
1077
1078 **/
1079 EFI_STATUS
1080 EFIAPI
1081 PlatOverMngrExtractConfig (
1082 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
1083 IN CONST EFI_STRING Request,
1084 OUT EFI_STRING *Progress,
1085 OUT EFI_STRING *Results
1086 )
1087 {
1088 EFI_STATUS Status;
1089 EFI_CALLBACK_INFO *Private;
1090 EFI_HII_CONFIG_ROUTING_PROTOCOL *HiiConfigRouting;
1091
1092 if (Request == NULL) {
1093 return EFI_NOT_FOUND;
1094 }
1095
1096 Private = EFI_CALLBACK_INFO_FROM_THIS (This);
1097 HiiConfigRouting = Private->HiiConfigRouting;
1098
1099 //
1100 // Convert buffer data to <ConfigResp> by helper function BlockToConfig()
1101 //
1102 Status = HiiConfigRouting->BlockToConfig (
1103 HiiConfigRouting,
1104 Request,
1105 (UINT8 *) &Private->FakeNvData,
1106 sizeof (PLAT_OVER_MNGR_DATA),
1107 Results,
1108 Progress
1109 );
1110 return Status;
1111 }
1112
1113 /**
1114 This function processes the results of changes in configuration.
1115
1116 @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
1117 @param Configuration A null-terminated Unicode string in <ConfigRequest> format.
1118 @param Progress A pointer to a string filled in with the offset of the most
1119 recent '&' before the first failing name/value pair (or the
1120 beginning of the string if the failure is in the first
1121 name/value pair) or the terminating NULL if all was successful.
1122
1123 @retval EFI_SUCCESS The Results is processed successfully.
1124 @retval EFI_INVALID_PARAMETER Configuration is NULL.
1125 @retval EFI_NOT_FOUND Routing data doesn't match any storage in this driver.
1126
1127 **/
1128 EFI_STATUS
1129 EFIAPI
1130 PlatOverMngrRouteConfig (
1131 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
1132 IN CONST EFI_STRING Configuration,
1133 OUT EFI_STRING *Progress
1134 )
1135 {
1136 EFI_CALLBACK_INFO *Private;
1137 EFI_STATUS Status;
1138 UINT16 KeyValue;
1139 UINTN BufferSize;
1140 PLAT_OVER_MNGR_DATA *FakeNvData;
1141
1142 Private = EFI_CALLBACK_INFO_FROM_THIS (This);
1143
1144 FakeNvData = &Private->FakeNvData;
1145 BufferSize = sizeof (PLAT_OVER_MNGR_DATA);
1146 Status = GetBrowserData (NULL, NULL, &BufferSize, (UINT8 *) FakeNvData);
1147 if (EFI_ERROR (Status)) {
1148 return Status;
1149 }
1150
1151 if (mCurrentPage == FORM_ID_DRIVER) {
1152 KeyValue = KEY_VALUE_DRIVER_GOTO_ORDER;
1153 UpdatePrioritySelectPage (Private, KeyValue, FakeNvData);
1154 KeyValue = KEY_VALUE_ORDER_SAVE_AND_EXIT;
1155 CommintChanges (Private, KeyValue, FakeNvData);
1156 //
1157 // Since UpdatePrioritySelectPage will change mCurrentPage,
1158 // should ensure the mCurrentPage still indicate the second page here
1159 //
1160 mCurrentPage = FORM_ID_DRIVER;
1161 }
1162
1163 if (mCurrentPage == FORM_ID_ORDER) {
1164 KeyValue = KEY_VALUE_ORDER_SAVE_AND_EXIT;
1165 CommintChanges (Private, KeyValue, FakeNvData);
1166 }
1167 return EFI_SUCCESS;
1168 }
1169
1170 /**
1171 This is the function that is called to provide results data to the driver. This data
1172 consists of a unique key which is used to identify what data is either being passed back
1173 or being asked for.
1174
1175 @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
1176 @param Action A null-terminated Unicode string in <ConfigRequest> format.
1177 @param KeyValue A unique Goto OpCode callback value which record user's selection.
1178 0x100 <= KeyValue <0x500 : user select a controller item in the first page;
1179 KeyValue == 0x1234 : user select 'Refresh' in first page, or user select 'Go to Previous Menu' in second page
1180 KeyValue == 0x1235 : user select 'Pci device filter' in first page
1181 KeyValue == 0x1500 : user select 'order ... priority' item in second page
1182 KeyValue == 0x1800 : user select 'commint changes' in third page
1183 KeyValue == 0x2000 : user select 'Go to Previous Menu' in third page
1184 @param Type The type of value for the question.
1185 @param Value A pointer to the data being sent to the original exporting driver.
1186 @param ActionRequest On return, points to the action requested by the callback function.
1187
1188 @retval EFI_SUCCESS Always returned.
1189
1190 **/
1191 EFI_STATUS
1192 EFIAPI
1193 PlatOverMngrCallback (
1194 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
1195 IN EFI_BROWSER_ACTION Action,
1196 IN EFI_QUESTION_ID KeyValue,
1197 IN UINT8 Type,
1198 IN EFI_IFR_TYPE_VALUE *Value,
1199 OUT EFI_BROWSER_ACTION_REQUEST *ActionRequest
1200 )
1201 {
1202 EFI_CALLBACK_INFO *Private;
1203 EFI_STATUS Status;
1204 EFI_STRING_ID NewStringToken;
1205 UINTN BufferSize;
1206 PLAT_OVER_MNGR_DATA *FakeNvData;
1207 EFI_INPUT_KEY Key;
1208
1209 Private = EFI_CALLBACK_INFO_FROM_THIS (This);
1210
1211 FakeNvData = &Private->FakeNvData;
1212 BufferSize = sizeof (PLAT_OVER_MNGR_DATA);
1213 Status = GetBrowserData (NULL, NULL, &BufferSize, (UINT8 *) FakeNvData);
1214 if (EFI_ERROR (Status)) {
1215 return Status;
1216 }
1217
1218 if (KeyValue == KEY_VALUE_DEVICE_REFRESH ||
1219 KeyValue == KEY_VALUE_DEVICE_FILTER ||
1220 KeyValue == KEY_VALUE_DRIVER_GOTO_PREVIOUS
1221 ) {
1222 UpdateDeviceSelectPage (Private, KeyValue, FakeNvData);
1223 //
1224 // Update page title string
1225 //
1226 NewStringToken = STRING_TOKEN (STR_TITLE);
1227 Status = HiiLibSetString (Private->RegisteredHandle, NewStringToken, L"First, Select the controller by device path");
1228 ASSERT_EFI_ERROR (Status);
1229 }
1230
1231 if (((KEY_VALUE_DEVICE_OFFSET <= KeyValue) && (KeyValue < KEY_VALUE_DEVICE_MAX)) || (KeyValue == KEY_VALUE_ORDER_GOTO_PREVIOUS)) {
1232 if (KeyValue == KEY_VALUE_ORDER_GOTO_PREVIOUS) {
1233 KeyValue = (EFI_QUESTION_ID) (mSelectedCtrIndex + KEY_VALUE_DEVICE_OFFSET);
1234 }
1235 UpdateBindingDriverSelectPage (Private, KeyValue, FakeNvData);
1236 //
1237 // Update page title string
1238 //
1239 NewStringToken = STRING_TOKEN (STR_TITLE);
1240 Status = HiiLibSetString (Private->RegisteredHandle, NewStringToken, L"Second, Select drivers for the previous selected controller");
1241 ASSERT_EFI_ERROR (Status);
1242 }
1243
1244 if (KeyValue == KEY_VALUE_DRIVER_GOTO_ORDER) {
1245 UpdatePrioritySelectPage (Private, KeyValue, FakeNvData);
1246 //
1247 // Update page title string
1248 //
1249 NewStringToken = STRING_TOKEN (STR_TITLE);
1250 Status = HiiLibSetString (Private->RegisteredHandle, NewStringToken, L"Finally, Set the priority order for the drivers and save them");
1251 ASSERT_EFI_ERROR (Status);
1252 }
1253
1254 if (KeyValue == KEY_VALUE_ORDER_SAVE_AND_EXIT) {
1255 Status = CommintChanges (Private, KeyValue, FakeNvData);
1256 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_SUBMIT;
1257 if (EFI_ERROR (Status)) {
1258 IfrLibCreatePopUp (1, &Key, L"Single Override Info too large, Saving Error!");
1259 return EFI_DEVICE_ERROR;
1260 }
1261 }
1262
1263 if (KeyValue == KEY_VALUE_DEVICE_CLEAR) {
1264 //
1265 // Deletes all environment variable(s) that contain the override mappings info
1266 //
1267 FreeMappingDatabase (&mMappingDataBase);
1268 Status = SaveOverridesMapping (&mMappingDataBase);
1269 UpdateDeviceSelectPage (Private, KeyValue, FakeNvData);
1270 }
1271 //
1272 // Pass changed uncommitted data back to Form Browser
1273 //
1274 BufferSize = sizeof (PLAT_OVER_MNGR_DATA);
1275 Status = SetBrowserData (NULL, NULL, BufferSize, (UINT8 *) FakeNvData, NULL);
1276
1277 return EFI_SUCCESS;
1278 }
1279
1280 /**
1281 The driver Entry Point. The funciton will export a disk device class formset and
1282 its callback function to hii database.
1283
1284 @param ImageHandle The firmware allocated handle for the EFI image.
1285 @param SystemTable A pointer to the EFI System Table.
1286
1287 @retval EFI_SUCCESS The entry point is executed successfully.
1288 @retval other Some error occurs when executing this entry point.
1289
1290 **/
1291 EFI_STATUS
1292 EFIAPI
1293 PlatOverMngrInit (
1294 IN EFI_HANDLE ImageHandle,
1295 IN EFI_SYSTEM_TABLE *SystemTable
1296 )
1297 {
1298 EFI_STATUS Status;
1299 EFI_HII_DATABASE_PROTOCOL *HiiDatabase;
1300 EFI_HII_PACKAGE_LIST_HEADER *PackageList;
1301 EFI_CALLBACK_INFO *CallbackInfo;
1302 EFI_HANDLE DriverHandle;
1303 EFI_FORM_BROWSER2_PROTOCOL *FormBrowser2;
1304
1305 //
1306 // There should only be one HII protocol
1307 //
1308 Status = gBS->LocateProtocol (
1309 &gEfiHiiDatabaseProtocolGuid,
1310 NULL,
1311 (VOID **) &HiiDatabase
1312 );
1313 if (EFI_ERROR (Status)) {
1314 return Status;
1315 }
1316
1317 //
1318 // There should only be one Form Configuration protocol
1319 //
1320 Status = gBS->LocateProtocol (
1321 &gEfiFormBrowser2ProtocolGuid,
1322 NULL,
1323 (VOID **) &FormBrowser2
1324 );
1325 if (EFI_ERROR (Status)) {
1326 return Status;
1327 }
1328
1329 CallbackInfo = AllocateZeroPool (sizeof (EFI_CALLBACK_INFO));
1330 if (CallbackInfo == NULL) {
1331 return EFI_BAD_BUFFER_SIZE;
1332 }
1333
1334 CallbackInfo->Signature = EFI_CALLBACK_INFO_SIGNATURE;
1335 CallbackInfo->ConfigAccess.ExtractConfig = PlatOverMngrExtractConfig;
1336 CallbackInfo->ConfigAccess.RouteConfig = PlatOverMngrRouteConfig;
1337 CallbackInfo->ConfigAccess.Callback = PlatOverMngrCallback;
1338
1339 //
1340 // Create driver handle used by HII database
1341 //
1342 Status = HiiLibCreateHiiDriverHandle (&DriverHandle);
1343 if (EFI_ERROR (Status)) {
1344 return Status;
1345 }
1346 CallbackInfo->DriverHandle = DriverHandle;
1347
1348 //
1349 // Install Config Access protocol to driver handle
1350 //
1351 Status = gBS->InstallProtocolInterface (
1352 &DriverHandle,
1353 &gEfiHiiConfigAccessProtocolGuid,
1354 EFI_NATIVE_INTERFACE,
1355 &CallbackInfo->ConfigAccess
1356 );
1357 if (EFI_ERROR (Status)) {
1358 return Status;
1359 }
1360
1361 //
1362 // Publish our HII data
1363 //
1364 PackageList = HiiLibPreparePackageList (
1365 2,
1366 &mPlatformOverridesManagerGuid,
1367 VfrBin,
1368 PlatOverMngrStrings
1369 );
1370 ASSERT (PackageList != NULL);
1371
1372 Status = HiiDatabase->NewPackageList (
1373 HiiDatabase,
1374 PackageList,
1375 DriverHandle,
1376 &CallbackInfo->RegisteredHandle
1377 );
1378 FreePool (PackageList);
1379
1380 //
1381 // Locate ConfigRouting protocol
1382 //
1383 Status = gBS->LocateProtocol (
1384 &gEfiHiiConfigRoutingProtocolGuid,
1385 NULL,
1386 (VOID **) &CallbackInfo->HiiConfigRouting
1387 );
1388 if (EFI_ERROR (Status)) {
1389 return Status;
1390 }
1391
1392 //
1393 // Clear all the globle variable
1394 //
1395 mDriverImageHandleCount = 0;
1396 mCurrentPage = 0;
1397 ZeroMem (mDriverImageToken, MAX_CHOICE_NUM * sizeof (EFI_STRING_ID));
1398 ZeroMem (mDriverImageFilePathToken, MAX_CHOICE_NUM * sizeof (EFI_STRING_ID));
1399 ZeroMem (mControllerToken, MAX_CHOICE_NUM * sizeof (EFI_STRING_ID));
1400 ZeroMem (mDriverImageProtocol, MAX_CHOICE_NUM * sizeof (EFI_LOADED_IMAGE_PROTOCOL *));
1401
1402 //
1403 // Show the page
1404 //
1405 Status = FormBrowser2->SendForm (
1406 FormBrowser2,
1407 &CallbackInfo->RegisteredHandle,
1408 1,
1409 NULL,
1410 0,
1411 NULL,
1412 NULL
1413 );
1414
1415 Status = HiiDatabase->RemovePackageList (HiiDatabase, CallbackInfo->RegisteredHandle);
1416 if (EFI_ERROR (Status)) {
1417 return Status;
1418 }
1419
1420 return EFI_SUCCESS;
1421 }
EFI Development Kit II mirror for PVE