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