]> git.proxmox.com Git - mirror_edk2.git/blame_incremental - MdeModulePkg/Universal/PlatformDriOverrideDxe/PlatDriOverrideDxe.c
projects / mirror_edk2.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
MdeModulePkg: Add DriverHealthManagerDxe driver.
[mirror_edk2.git] / MdeModulePkg / Universal / PlatformDriOverrideDxe / PlatDriOverrideDxe.c
... / ...
CommitLineData
1/** @file\r
2 This file also installs UEFI PLATFORM_DRIVER_OVERRIDE_PROTOCOL.\r
3 \r
4 The main code offers a UI interface in device manager to let user configure\r
5 platform override protocol to override the default algorithm for matching\r
6 drivers to controllers.\r
7\r
8 The main flow:\r
9 1. It dynamicly locate all controller device path.\r
10 2. It dynamicly locate all drivers which support binding protocol.\r
11 3. It export and dynamicly update two menu to let user select the\r
12 mapping between drivers to controllers.\r
13 4. It save all the mapping info in NV variables which will be consumed\r
14 by platform override protocol driver to publish the platform override protocol.\r
15\r
16Copyright (c) 2007 - 2015, Intel Corporation. All rights reserved.<BR>\r
17This program and the accompanying materials\r
18are licensed and made available under the terms and conditions of the BSD License\r
19which accompanies this distribution. The full text of the license may be found at\r
20http://opensource.org/licenses/bsd-license.php\r
21\r
22THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
23WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
24\r
25**/\r
26\r
27#include "InternalPlatDriOverrideDxe.h"\r
28#include "PlatOverMngr.h"\r
29\r
30#define EFI_CALLBACK_INFO_SIGNATURE SIGNATURE_32 ('C', 'l', 'b', 'k')\r
31#define EFI_CALLBACK_INFO_FROM_THIS(a) CR (a, EFI_CALLBACK_INFO, ConfigAccess, EFI_CALLBACK_INFO_SIGNATURE)\r
32\r
33typedef struct {\r
34 UINTN Signature;\r
35 EFI_HANDLE DriverHandle;\r
36 EFI_HII_HANDLE RegisteredHandle;\r
37 PLAT_OVER_MNGR_DATA FakeNvData;\r
38 EFI_HII_CONFIG_ROUTING_PROTOCOL *HiiConfigRouting;\r
39 EFI_HII_CONFIG_ACCESS_PROTOCOL ConfigAccess;\r
40 EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL PlatformDriverOverride;\r
41} EFI_CALLBACK_INFO;\r
42\r
43#pragma pack(1)\r
44\r
45///\r
46/// HII specific Vendor Device Path definition.\r
47///\r
48typedef struct {\r
49 VENDOR_DEVICE_PATH VendorDevicePath;\r
50 EFI_DEVICE_PATH_PROTOCOL End;\r
51} HII_VENDOR_DEVICE_PATH;\r
52\r
53#pragma pack()\r
54\r
55//\r
56// uni string and Vfr Binary data.\r
57//\r
58extern UINT8 VfrBin[];\r
59extern UINT8 PlatDriOverrideDxeStrings[];\r
60\r
61//\r
62// module global data\r
63//\r
64CHAR16 mVariableName[] = L"Data";\r
65LIST_ENTRY mMappingDataBase = INITIALIZE_LIST_HEAD_VARIABLE (mMappingDataBase);\r
66BOOLEAN mEnvironmentVariableRead = FALSE;\r
67EFI_HANDLE mCallerImageHandle = NULL;\r
68\r
69EFI_HANDLE *mDevicePathHandleBuffer;\r
70EFI_HANDLE *mDriverImageHandleBuffer;\r
71\r
72INTN mSelectedCtrIndex;\r
73EFI_STRING_ID *mControllerToken;\r
74UINTN mDriverImageHandleCount;\r
75EFI_STRING_ID *mDriverImageToken;\r
76EFI_DEVICE_PATH_PROTOCOL **mControllerDevicePathProtocol;\r
77UINTN mSelectedDriverImageNum;\r
78UINTN mLastSavedDriverImageNum;\r
79UINT16 mCurrentPage;\r
80EFI_CALLBACK_INFO *mCallbackInfo;\r
81BOOLEAN *mDriSelection;\r
82UINTN mMaxDeviceCount;\r
83\r
84HII_VENDOR_DEVICE_PATH mHiiVendorDevicePath = {\r
85 {\r
86 {\r
87 HARDWARE_DEVICE_PATH,\r
88 HW_VENDOR_DP,\r
89 {\r
90 (UINT8) (sizeof (VENDOR_DEVICE_PATH)),\r
91 (UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8)\r
92 }\r
93 },\r
94 PLAT_OVER_MNGR_GUID\r
95 },\r
96 {\r
97 END_DEVICE_PATH_TYPE,\r
98 END_ENTIRE_DEVICE_PATH_SUBTYPE,\r
99 { \r
100 (UINT8) (END_DEVICE_PATH_LENGTH),\r
101 (UINT8) ((END_DEVICE_PATH_LENGTH) >> 8)\r
102 }\r
103 }\r
104};\r
105\r
106/**\r
107 Converting a given device to an unicode string.\r
108\r
109 @param DevPath Given device path instance\r
110 \r
111 @return Converted string from given device path.\r
112 @retval L"?" Converting failed.\r
113**/\r
114CHAR16 *\r
115DevicePathToStr (\r
116 IN EFI_DEVICE_PATH_PROTOCOL *DevPath\r
117 )\r
118{\r
119 CHAR16 *Text;\r
120 Text = ConvertDevicePathToText (\r
121 DevPath,\r
122 FALSE,\r
123 TRUE\r
124 );\r
125 if (Text == NULL) {\r
126 Text = AllocateCopyPool (sizeof (L"?"), L"?");\r
127 ASSERT (Text != NULL);\r
128 }\r
129\r
130 return Text;\r
131}\r
132\r
133/**\r
134 Worker function to get the driver name by ComponentName or ComponentName2 protocol \r
135 according to the driver binding handle.\r
136\r
137 @param DriverBindingHandle The Handle of DriverBinding.\r
138 @param ProtocolGuid The pointer to Component Name (2) protocol GUID.\r
139 @param VariableName The name of the RFC 4646 or ISO 639-2 language variable.\r
140\r
141 @retval !NULL Pointer into the image name if the image name is found,\r
142 @retval NULL Pointer to NULL if the image name is not found.\r
143\r
144**/\r
145CHAR16 *\r
146GetComponentNameWorker (\r
147 IN EFI_HANDLE DriverBindingHandle,\r
148 IN EFI_GUID *ProtocolGuid,\r
149 IN CONST CHAR16 *VariableName\r
150 )\r
151{\r
152 EFI_STATUS Status;\r
153 EFI_COMPONENT_NAME_PROTOCOL *ComponentName;\r
154 CHAR16 *DriverName;\r
155 CHAR8 *Language;\r
156 CHAR8 *BestLanguage;\r
157\r
158 Status = gBS->OpenProtocol (\r
159 DriverBindingHandle,\r
160 ProtocolGuid,\r
161 (VOID *) &ComponentName,\r
162 NULL,\r
163 NULL,\r
164 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
165 );\r
166 if (EFI_ERROR (Status)) {\r
167 return NULL;\r
168 }\r
169\r
170 //\r
171 // Find the best matching language.\r
172 //\r
173 GetEfiGlobalVariable2 (VariableName, (VOID**)&Language, NULL);\r
174 BestLanguage = GetBestLanguage (\r
175 ComponentName->SupportedLanguages,\r
176 (BOOLEAN) (ProtocolGuid == &gEfiComponentNameProtocolGuid),\r
177 Language,\r
178 NULL\r
179 );\r
180\r
181 DriverName = NULL;\r
182 if (BestLanguage != NULL) {\r
183 ComponentName->GetDriverName (\r
184 ComponentName,\r
185 BestLanguage,\r
186 &DriverName\r
187 );\r
188 FreePool (BestLanguage);\r
189 }\r
190\r
191 if (Language != NULL) {\r
192 FreePool (Language);\r
193 }\r
194\r
195 return DriverName;\r
196}\r
197\r
198\r
199/**\r
200 Get the driver name by ComponentName or ComponentName2 protocol \r
201 according to the driver binding handle\r
202\r
203 @param DriverBindingHandle The Handle of DriverBinding.\r
204\r
205 @retval !NULL Pointer into the image name if the image name is found,\r
206 @retval NULL Pointer to NULL if the image name is not found.\r
207\r
208**/\r
209CHAR16 *\r
210GetComponentName (\r
211 IN EFI_HANDLE DriverBindingHandle\r
212 )\r
213{\r
214 CHAR16 *DriverName;\r
215\r
216 //\r
217 // Try RFC 4646 Component Name 2 protocol first.\r
218 //\r
219 DriverName = GetComponentNameWorker (DriverBindingHandle, &gEfiComponentName2ProtocolGuid, L"PlatformLang");\r
220 if (DriverName == NULL) {\r
221 //\r
222 // If we can not get driver name from Component Name 2 protocol, we can try ISO 639-2 Component Name protocol. \r
223 //\r
224 DriverName = GetComponentNameWorker (DriverBindingHandle, &gEfiComponentNameProtocolGuid, L"Lang");\r
225 }\r
226\r
227 return DriverName;\r
228}\r
229\r
230/**\r
231 Get the image name from EFI UI section.\r
232 Get FV protocol by its loaded image protocol to abstract EFI UI section.\r
233\r
234 @param Image Pointer to the loaded image protocol\r
235\r
236 @retval !NULL Pointer to the image name if the image name is found,\r
237 @retval NULL NULL if the image name is not found.\r
238\r
239**/\r
240CHAR16 *\r
241GetImageName (\r
242 IN EFI_LOADED_IMAGE_PROTOCOL *Image\r
243 )\r
244{\r
245 EFI_STATUS Status;\r
246 EFI_DEVICE_PATH_PROTOCOL *DevPathNode;\r
247 EFI_DEVICE_PATH_PROTOCOL *AlignedDevPathNode;\r
248 MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *FvFilePath;\r
249 VOID *Buffer;\r
250 UINTN BufferSize;\r
251 UINT32 AuthenticationStatus;\r
252 EFI_GUID *NameGuid;\r
253 EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv2;\r
254\r
255 Fv2 = NULL;\r
256 Buffer = NULL;\r
257 BufferSize = 0;\r
258\r
259 if (Image->FilePath == NULL) {\r
260 return NULL;\r
261 }\r
262 DevPathNode = Image->FilePath;\r
263\r
264 while (!IsDevicePathEnd (DevPathNode)) {\r
265 //\r
266 // Make sure device path node is aligned when accessing it's FV Name Guid field.\r
267 //\r
268 AlignedDevPathNode = AllocateCopyPool (DevicePathNodeLength(DevPathNode), DevPathNode);\r
269 \r
270 //\r
271 // Find the Fv File path\r
272 //\r
273 NameGuid = EfiGetNameGuidFromFwVolDevicePathNode ((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *)AlignedDevPathNode);\r
274 if (NameGuid != NULL) {\r
275 FvFilePath = (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) AlignedDevPathNode;\r
276 Status = gBS->HandleProtocol (\r
277 Image->DeviceHandle,\r
278 &gEfiFirmwareVolume2ProtocolGuid,\r
279 (VOID **) &Fv2\r
280 );\r
281 //\r
282 // Locate Image EFI UI section to get the image name.\r
283 //\r
284 if (!EFI_ERROR (Status)) {\r
285 Status = Fv2->ReadSection (\r
286 Fv2,\r
287 &FvFilePath->FvFileName,\r
288 EFI_SECTION_USER_INTERFACE,\r
289 0,\r
290 &Buffer,\r
291 &BufferSize,\r
292 &AuthenticationStatus\r
293 );\r
294 if (!EFI_ERROR (Status)) {\r
295 FreePool (AlignedDevPathNode);\r
296 break;\r
297 }\r
298 Buffer = NULL;\r
299 }\r
300 }\r
301 \r
302 FreePool (AlignedDevPathNode);\r
303 \r
304 //\r
305 // Next device path node\r
306 //\r
307 DevPathNode = NextDevicePathNode (DevPathNode);\r
308 }\r
309\r
310 return Buffer;\r
311}\r
312\r
313/**\r
314 Prepare the first page to let user select the device controller which need to\r
315 add mapping drivers if user select 'Refresh' in first page.\r
316 During first page, user will see all currnet controller device path in system,\r
317 select any device path will go to second page to select its overrides drivers.\r
318\r
319 @param Private Pointer to EFI_CALLBACK_INFO.\r
320 @param KeyValue The callback key value of device controller item in first page.\r
321 @param FakeNvData Pointer to PLAT_OVER_MNGR_DATA.\r
322\r
323 @retval EFI_SUCCESS Always returned.\r
324\r
325**/\r
326EFI_STATUS\r
327UpdateDeviceSelectPage (\r
328 IN EFI_CALLBACK_INFO *Private,\r
329 IN UINT16 KeyValue,\r
330 IN PLAT_OVER_MNGR_DATA *FakeNvData\r
331 )\r
332{\r
333 EFI_STATUS Status;\r
334 UINTN Index;\r
335 UINTN DevicePathHandleCount;\r
336 CHAR16 *NewString;\r
337 EFI_STRING_ID NewStringToken;\r
338 CHAR16 *ControllerName;\r
339 EFI_DEVICE_PATH_PROTOCOL *ControllerDevicePath;\r
340 EFI_PCI_IO_PROTOCOL *PciIo;\r
341 EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL *BusSpecificDriverOverride;\r
342 UINTN Len;\r
343 VOID *StartOpCodeHandle;\r
344 VOID *EndOpCodeHandle;\r
345 EFI_IFR_GUID_LABEL *StartLabel;\r
346 EFI_IFR_GUID_LABEL *EndLabel; \r
347\r
348 //\r
349 // Set current page form ID.\r
350 //\r
351 mCurrentPage = FORM_ID_DEVICE; \r
352 \r
353 //\r
354 // Initial the mapping database in memory\r
355 //\r
356 FreeMappingDatabase (&mMappingDataBase);\r
357 InitOverridesMapping (&mMappingDataBase);\r
358\r
359 //\r
360 // Init OpCode Handle\r
361 //\r
362 StartOpCodeHandle = HiiAllocateOpCodeHandle ();\r
363 ASSERT (StartOpCodeHandle != NULL);\r
364\r
365 EndOpCodeHandle = HiiAllocateOpCodeHandle ();\r
366 ASSERT (EndOpCodeHandle != NULL);\r
367\r
368 //\r
369 // Create Hii Extend Label OpCode as the start opcode\r
370 //\r
371 StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (StartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));\r
372 StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;\r
373 StartLabel->Number = FORM_ID_DEVICE;\r
374\r
375 //\r
376 // Create Hii Extend Label OpCode as the end opcode\r
377 //\r
378 EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (EndOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));\r
379 EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;\r
380 EndLabel->Number = LABEL_END;\r
381\r
382 //\r
383 // Clear first page form\r
384 //\r
385 HiiUpdateForm (\r
386 Private->RegisteredHandle,\r
387 &gPlatformOverridesManagerGuid,\r
388 FORM_ID_DEVICE,\r
389 StartOpCodeHandle, // Label FORM_ID_DEVICE\r
390 EndOpCodeHandle // LABEL_END\r
391 );\r
392\r
393 //\r
394 // When user enter the page at first time, the 'first refresh' string is given to notify user to refresh all the drivers,\r
395 // then the 'first refresh' string will be replaced by the 'refresh' string, and the two strings content are same after the replacement\r
396 //\r
397 NewStringToken = STRING_TOKEN (STR_FIRST_REFRESH);\r
398 NewString = HiiGetString (Private->RegisteredHandle, STRING_TOKEN (STR_REFRESH), NULL);\r
399 ASSERT (NewString != NULL);\r
400 if (HiiSetString (Private->RegisteredHandle, NewStringToken, NewString, NULL) == 0) {\r
401 ASSERT (FALSE);\r
402 }\r
403 FreePool (NewString);\r
404\r
405 NewStringToken = STRING_TOKEN (STR_FIRST_REFRESH_HELP);\r
406 NewString = HiiGetString (Private->RegisteredHandle, STRING_TOKEN (STR_REFRESH_HELP), NULL);\r
407 ASSERT (NewString != NULL);\r
408 if (HiiSetString (Private->RegisteredHandle, NewStringToken, NewString, NULL) == 0) {\r
409 ASSERT (FALSE);\r
410 }\r
411 FreePool (NewString);\r
412\r
413 //\r
414 // created needed controller device item in first page\r
415 //\r
416 DevicePathHandleCount = 0;\r
417 Status = gBS->LocateHandleBuffer (\r
418 ByProtocol,\r
419 &gEfiDevicePathProtocolGuid,\r
420 NULL,\r
421 &DevicePathHandleCount,\r
422 &mDevicePathHandleBuffer\r
423 );\r
424 if (EFI_ERROR (Status) || (DevicePathHandleCount == 0)) {\r
425 return EFI_SUCCESS;\r
426 }\r
427\r
428 mMaxDeviceCount = DevicePathHandleCount;\r
429 mControllerDevicePathProtocol = AllocateZeroPool (DevicePathHandleCount * sizeof (EFI_DEVICE_PATH_PROTOCOL *));\r
430 ASSERT (mControllerDevicePathProtocol != NULL);\r
431 mControllerToken = AllocateZeroPool (DevicePathHandleCount * sizeof (EFI_STRING_ID));\r
432 ASSERT (mControllerToken != NULL);\r
433\r
434 for (Index = 0; Index < DevicePathHandleCount; Index++) {\r
435 if (FakeNvData->PciDeviceFilter == 0x01) {\r
436 //\r
437 // Only care PCI device which contain efi driver in its option rom.\r
438 //\r
439\r
440 //\r
441 // Check whether it is a pci device\r
442 //\r
443 ControllerDevicePath = NULL;\r
444 Status = gBS->OpenProtocol (\r
445 mDevicePathHandleBuffer[Index],\r
446 &gEfiPciIoProtocolGuid,\r
447 (VOID **) &PciIo,\r
448 NULL,\r
449 NULL,\r
450 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
451 );\r
452 if (EFI_ERROR (Status)) {\r
453 continue;\r
454 }\r
455 //\r
456 // Check whether it contain efi driver in its option rom\r
457 //\r
458 Status = gBS->HandleProtocol(\r
459 mDevicePathHandleBuffer[Index],\r
460 &gEfiBusSpecificDriverOverrideProtocolGuid,\r
461 (VOID **) &BusSpecificDriverOverride\r
462 );\r
463 if (EFI_ERROR (Status) || BusSpecificDriverOverride == NULL) {\r
464 continue;\r
465 }\r
466 }\r
467\r
468 ControllerDevicePath = NULL;\r
469 Status = gBS->OpenProtocol (\r
470 mDevicePathHandleBuffer[Index],\r
471 &gEfiDevicePathProtocolGuid,\r
472 (VOID **) &ControllerDevicePath,\r
473 NULL,\r
474 NULL,\r
475 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
476 );\r
477 ASSERT_EFI_ERROR (Status);\r
478 //\r
479 // Save the device path protocol interface\r
480 //\r
481 mControllerDevicePathProtocol[Index] = ControllerDevicePath;\r
482\r
483 //\r
484 // Get the driver name\r
485 //\r
486 ControllerName = DevicePathToStr (ControllerDevicePath);\r
487\r
488 //\r
489 // Export the driver name string and create item in set options page\r
490 //\r
491 Len = StrSize (ControllerName);\r
492 NewString = AllocateZeroPool (Len + StrSize (L"--"));\r
493 ASSERT (NewString != NULL);\r
494 if (EFI_ERROR (CheckMapping (ControllerDevicePath,NULL, &mMappingDataBase, NULL, NULL))) {\r
495 StrCat (NewString, L"--");\r
496 } else {\r
497 StrCat (NewString, L"**");\r
498 }\r
499 StrCat (NewString, ControllerName);\r
500\r
501 NewStringToken = HiiSetString (Private->RegisteredHandle, mControllerToken[Index], NewString, NULL);\r
502 ASSERT (NewStringToken != 0);\r
503 FreePool (NewString);\r
504 //\r
505 // Save the device path string toke for next access use\r
506 //\r
507 mControllerToken[Index] = NewStringToken;\r
508 \r
509 HiiCreateGotoOpCode (\r
510 StartOpCodeHandle,\r
511 FORM_ID_DRIVER,\r
512 NewStringToken,\r
513 STRING_TOKEN (STR_GOTO_HELP_DRIVER),\r
514 EFI_IFR_FLAG_CALLBACK,\r
515 (UINT16) (Index + KEY_VALUE_DEVICE_OFFSET)\r
516 );\r
517 }\r
518\r
519 //\r
520 // Update first page form\r
521 //\r
522 HiiUpdateForm (\r
523 Private->RegisteredHandle,\r
524 &gPlatformOverridesManagerGuid,\r
525 FORM_ID_DEVICE,\r
526 StartOpCodeHandle, // Label FORM_ID_DEVICE\r
527 EndOpCodeHandle // LABEL_END\r
528 );\r
529\r
530 HiiFreeOpCodeHandle (StartOpCodeHandle);\r
531 HiiFreeOpCodeHandle (EndOpCodeHandle);\r
532\r
533 return EFI_SUCCESS;\r
534}\r
535\r
536/**\r
537 Get the first Driver Binding handle which has the specific image handle.\r
538\r
539 @param ImageHandle The Image handle\r
540\r
541 @return Handle to Driver binding\r
542 @retval NULL The paramter is not valid or the driver binding handle is not found.\r
543\r
544**/\r
545EFI_HANDLE\r
546GetDriverBindingHandleFromImageHandle (\r
547 IN EFI_HANDLE ImageHandle\r
548 )\r
549{\r
550 EFI_STATUS Status;\r
551 UINTN Index;\r
552 UINTN DriverBindingHandleCount;\r
553 EFI_HANDLE *DriverBindingHandleBuffer;\r
554 EFI_DRIVER_BINDING_PROTOCOL *DriverBindingInterface;\r
555 EFI_HANDLE DriverBindingHandle;\r
556\r
557 DriverBindingHandle = NULL;\r
558\r
559 if (ImageHandle == NULL) {\r
560 return NULL;\r
561 }\r
562 //\r
563 // Get all drivers which support driver binding protocol\r
564 //\r
565 DriverBindingHandleCount = 0;\r
566 Status = gBS->LocateHandleBuffer (\r
567 ByProtocol,\r
568 &gEfiDriverBindingProtocolGuid,\r
569 NULL,\r
570 &DriverBindingHandleCount,\r
571 &DriverBindingHandleBuffer\r
572 );\r
573 if (EFI_ERROR (Status) || (DriverBindingHandleCount == 0)) {\r
574 return NULL;\r
575 }\r
576 \r
577 //\r
578 // Get the first Driver Binding handle which has the specific image handle.\r
579 //\r
580 for (Index = 0; Index < DriverBindingHandleCount; Index++) {\r
581 DriverBindingInterface = NULL;\r
582 Status = gBS->OpenProtocol (\r
583 DriverBindingHandleBuffer[Index],\r
584 &gEfiDriverBindingProtocolGuid,\r
585 (VOID **) &DriverBindingInterface,\r
586 NULL,\r
587 NULL,\r
588 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
589 );\r
590 if (EFI_ERROR (Status)) {\r
591 continue;\r
592 }\r
593\r
594 if (DriverBindingInterface->ImageHandle == ImageHandle) {\r
595 DriverBindingHandle = DriverBindingHandleBuffer[Index];\r
596 break;\r
597 }\r
598 }\r
599\r
600 FreePool (DriverBindingHandleBuffer);\r
601 return DriverBindingHandle;\r
602}\r
603\r
604/**\r
605 Prepare to let user select the drivers which need mapping with the device controller\r
606 selected in first page.\r
607\r
608 @param Private Pointer to EFI_CALLBACK_INFO.\r
609 @param KeyValue The callback key value of device controller item in first page.\r
610 KeyValue is larger than or equal to KEY_VALUE_DEVICE_OFFSET.\r
611 @param FakeNvData Pointer to PLAT_OVER_MNGR_DATA.\r
612\r
613 @retval EFI_SUCCESS Always returned.\r
614\r
615**/\r
616EFI_STATUS\r
617UpdateBindingDriverSelectPage (\r
618 IN EFI_CALLBACK_INFO *Private,\r
619 IN UINT16 KeyValue,\r
620 IN PLAT_OVER_MNGR_DATA *FakeNvData\r
621 )\r
622{\r
623 EFI_STATUS Status;\r
624 UINTN Index;\r
625 CHAR16 *NewString;\r
626 EFI_STRING_ID NewStringToken;\r
627 EFI_STRING_ID NewStringHelpToken;\r
628 UINTN DriverImageHandleCount;\r
629 EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;\r
630 CHAR16 *DriverName;\r
631 BOOLEAN FreeDriverName;\r
632 EFI_DEVICE_PATH_PROTOCOL *LoadedImageDevicePath;\r
633 EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL *BusSpecificDriverOverride;\r
634 EFI_HANDLE DriverBindingHandle;\r
635 VOID *StartOpCodeHandle;\r
636 VOID *EndOpCodeHandle;\r
637 EFI_IFR_GUID_LABEL *StartLabel;\r
638 EFI_IFR_GUID_LABEL *EndLabel;\r
639 EFI_LOADED_IMAGE_PROTOCOL **DriverImageProtocol;\r
640 EFI_STRING_ID *DriverImageFilePathToken;\r
641 UINT8 CheckFlags;\r
642\r
643 //\r
644 // If user select a controller item in the first page the following code will be run.\r
645 // During second page, user will see all currnet driver bind protocol driver, the driver name and its device path will be shown\r
646 //\r
647 //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
648 // and find the first one whose ImageHandle field matches the image handle of the Loaded Image Protocol.\r
649 // 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
650 //\r
651\r
652 mCurrentPage = FORM_ID_DRIVER;\r
653 //\r
654 // Switch the item callback key value to its NO. in mDevicePathHandleBuffer\r
655 //\r
656 mSelectedCtrIndex = KeyValue - KEY_VALUE_DEVICE_OFFSET;\r
657 ASSERT (mSelectedCtrIndex >= 0 && mSelectedCtrIndex < MAX_CHOICE_NUM);\r
658\r
659 mLastSavedDriverImageNum = 0;\r
660\r
661 //\r
662 // Init OpCode Handle\r
663 //\r
664 StartOpCodeHandle = HiiAllocateOpCodeHandle ();\r
665 ASSERT (StartOpCodeHandle != NULL);\r
666\r
667 EndOpCodeHandle = HiiAllocateOpCodeHandle ();\r
668 ASSERT (EndOpCodeHandle != NULL);\r
669\r
670 //\r
671 // Create Hii Extend Label OpCode as the start opcode\r
672 //\r
673 StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (StartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));\r
674 StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;\r
675 StartLabel->Number = FORM_ID_DRIVER;\r
676\r
677 //\r
678 // Create Hii Extend Label OpCode as the end opcode\r
679 //\r
680 EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (EndOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));\r
681 EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;\r
682 EndLabel->Number = LABEL_END;\r
683\r
684 //\r
685 // Clear second page form\r
686 //\r
687 HiiUpdateForm (\r
688 Private->RegisteredHandle,\r
689 &gPlatformOverridesManagerGuid,\r
690 FORM_ID_DRIVER,\r
691 StartOpCodeHandle,\r
692 EndOpCodeHandle\r
693 );\r
694\r
695 //\r
696 // Show all driver which support loaded image protocol in second page\r
697 //\r
698 DriverImageHandleCount = 0;\r
699 Status = gBS->LocateHandleBuffer (\r
700 ByProtocol,\r
701 &gEfiLoadedImageProtocolGuid,\r
702 NULL,\r
703 &DriverImageHandleCount,\r
704 &mDriverImageHandleBuffer\r
705 );\r
706 if (EFI_ERROR (Status) || (DriverImageHandleCount == 0)) {\r
707 return EFI_NOT_FOUND;\r
708 }\r
709\r
710 mDriverImageToken = AllocateZeroPool (DriverImageHandleCount * sizeof (EFI_STRING_ID));\r
711 ASSERT (mDriverImageToken != NULL);\r
712 mDriSelection = AllocateZeroPool (DriverImageHandleCount * sizeof (BOOLEAN));\r
713 ASSERT (mDriSelection != NULL);\r
714\r
715 DriverImageProtocol = AllocateZeroPool (DriverImageHandleCount * sizeof (EFI_LOADED_IMAGE_PROTOCOL *));\r
716 ASSERT (DriverImageProtocol != NULL);\r
717 DriverImageFilePathToken = AllocateZeroPool (DriverImageHandleCount * sizeof (EFI_STRING_ID));\r
718 ASSERT (DriverImageFilePathToken != NULL);\r
719\r
720 mDriverImageHandleCount = DriverImageHandleCount;\r
721 for (Index = 0; Index < DriverImageHandleCount; Index++) {\r
722 //\r
723 // Step1: Get the driver image total file path for help string and the driver name.\r
724 //\r
725\r
726 //\r
727 // Find driver's Loaded Image protocol\r
728 //\r
729 LoadedImage =NULL;\r
730\r
731 Status = gBS->OpenProtocol (\r
732 mDriverImageHandleBuffer[Index],\r
733 &gEfiLoadedImageProtocolGuid,\r
734 (VOID **) &LoadedImage,\r
735 NULL,\r
736 NULL,\r
737 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
738 );\r
739 if (EFI_ERROR (Status)) {\r
740 mDriSelection[Index] = FALSE;\r
741 continue;\r
742 }\r
743 DriverImageProtocol[Index] = LoadedImage;\r
744 //\r
745 // Find its related driver binding protocol\r
746 //\r
747 DriverBindingHandle = GetDriverBindingHandleFromImageHandle (mDriverImageHandleBuffer[Index]);\r
748 if (DriverBindingHandle == NULL) {\r
749 mDriSelection[Index] = FALSE;\r
750 continue;\r
751 }\r
752\r
753 //\r
754 // Get the EFI Loaded Image Device Path Protocol\r
755 //\r
756 LoadedImageDevicePath = NULL;\r
757 Status = gBS->HandleProtocol (\r
758 mDriverImageHandleBuffer[Index],\r
759 &gEfiLoadedImageDevicePathProtocolGuid,\r
760 (VOID **) &LoadedImageDevicePath\r
761 );\r
762 if (LoadedImageDevicePath == NULL) {\r
763 mDriSelection[Index] = FALSE;\r
764 continue;\r
765 }\r
766\r
767 if (FakeNvData->PciDeviceFilter == 0x01) {\r
768 //\r
769 // only care the driver which is in a Pci device option rom,\r
770 // and the driver's LoadedImage->DeviceHandle must point to a pci device which has efi option rom\r
771 //\r
772 if (!EFI_ERROR (Status)) {\r
773 Status = gBS->HandleProtocol(\r
774 LoadedImage->DeviceHandle,\r
775 &gEfiBusSpecificDriverOverrideProtocolGuid,\r
776 (VOID **) &BusSpecificDriverOverride\r
777 );\r
778 if (EFI_ERROR (Status) || BusSpecificDriverOverride == NULL) {\r
779 mDriSelection[Index] = FALSE;\r
780 continue;\r
781 }\r
782 } else {\r
783 mDriSelection[Index] = FALSE;\r
784 continue;\r
785 }\r
786 }\r
787\r
788 //\r
789 // For driver name, try to get its component name, if fail, get its image name,\r
790 // if also fail, give a default name.\r
791 //\r
792 FreeDriverName = FALSE;\r
793 DriverName = GetComponentName (DriverBindingHandle);\r
794 if (DriverName == NULL) {\r
795 //\r
796 // get its image name\r
797 //\r
798 DriverName = GetImageName (LoadedImage);\r
799 }\r
800 if (DriverName == NULL) {\r
801 //\r
802 // give a default name\r
803 //\r
804 DriverName = HiiGetString (Private->RegisteredHandle, STRING_TOKEN (STR_DRIVER_DEFAULT_NAME), NULL);\r
805 ASSERT (DriverName != NULL);\r
806 FreeDriverName = TRUE; // the DriverName string need to free pool\r
807 }\r
808\r
809\r
810 //\r
811 // Step2 Export the driver name string and create check box item in second page\r
812 //\r
813\r
814 //\r
815 // First create the driver image name\r
816 //\r
817 NewString = AllocateZeroPool (StrSize (DriverName));\r
818 ASSERT (NewString != NULL); \r
819 if (EFI_ERROR (CheckMapping (mControllerDevicePathProtocol[mSelectedCtrIndex], LoadedImageDevicePath, &mMappingDataBase, NULL, NULL))) {\r
820 mDriSelection[Index] = FALSE;\r
821 } else {\r
822 mDriSelection[Index] = TRUE;\r
823 mLastSavedDriverImageNum++;\r
824 }\r
825 StrCat (NewString, DriverName);\r
826 NewStringToken = HiiSetString (Private->RegisteredHandle, mDriverImageToken[Index], NewString, NULL);\r
827 ASSERT (NewStringToken != 0);\r
828 mDriverImageToken[Index] = NewStringToken;\r
829 FreePool (NewString);\r
830 if (FreeDriverName) {\r
831 FreePool (DriverName);\r
832 }\r
833\r
834 //\r
835 // Second create the driver image device path as item help string\r
836 //\r
837 DriverName = DevicePathToStr (LoadedImageDevicePath);\r
838\r
839 NewString = AllocateZeroPool (StrSize (DriverName));\r
840 ASSERT (NewString != NULL); \r
841 StrCat (NewString, DriverName);\r
842 NewStringHelpToken = HiiSetString (Private->RegisteredHandle, DriverImageFilePathToken[Index], NewString, NULL);\r
843 ASSERT (NewStringHelpToken != 0);\r
844 DriverImageFilePathToken[Index] = NewStringHelpToken;\r
845 FreePool (NewString);\r
846 FreePool (DriverName);\r
847\r
848 CheckFlags = 0;\r
849 if (mDriSelection[Index]) {\r
850 CheckFlags |= EFI_IFR_CHECKBOX_DEFAULT;\r
851 }\r
852\r
853 HiiCreateCheckBoxOpCode (\r
854 StartOpCodeHandle,\r
855 (UINT16) (KEY_VALUE_DRIVER_OFFSET + Index),\r
856 0,\r
857 0,\r
858 NewStringToken,\r
859 NewStringHelpToken,\r
860 EFI_IFR_FLAG_CALLBACK,\r
861 CheckFlags,\r
862 NULL\r
863 );\r
864 }\r
865\r
866 //\r
867 // Update second page form\r
868 //\r
869 HiiUpdateForm (\r
870 Private->RegisteredHandle,\r
871 &gPlatformOverridesManagerGuid,\r
872 FORM_ID_DRIVER,\r
873 StartOpCodeHandle, // Label FORM_ID_DRIVER\r
874 EndOpCodeHandle // LABEL_END\r
875 );\r
876\r
877 HiiFreeOpCodeHandle (StartOpCodeHandle);\r
878 HiiFreeOpCodeHandle (EndOpCodeHandle);\r
879\r
880 if (DriverImageProtocol != NULL) {\r
881 FreePool (DriverImageProtocol);\r
882 }\r
883\r
884 if (DriverImageFilePathToken != NULL) {\r
885 FreePool (DriverImageFilePathToken);\r
886 }\r
887\r
888 return EFI_SUCCESS;\r
889}\r
890\r
891/**\r
892 Prepare to let user select the priority order of the drivers which are\r
893 selected in second page.\r
894\r
895 @param Private Pointer to EFI_CALLBACK_INFO.\r
896 @param KeyValue The callback key value of device controller item in first page.\r
897 @param FakeNvData Pointer to PLAT_OVER_MNGR_DATA.\r
898\r
899 @retval EFI_SUCCESS Always returned.\r
900\r
901**/\r
902EFI_STATUS\r
903UpdatePrioritySelectPage (\r
904 IN EFI_CALLBACK_INFO *Private,\r
905 IN UINT16 KeyValue,\r
906 IN PLAT_OVER_MNGR_DATA *FakeNvData\r
907 )\r
908{\r
909 UINTN Index;\r
910 EFI_DEVICE_PATH_PROTOCOL *LoadedImageDevicePath;\r
911 UINTN SelectedDriverImageNum;\r
912 UINT32 DriverImageNO;\r
913 UINTN MinNO;\r
914 UINTN Index1;\r
915 UINTN TempNO[100];\r
916 UINTN OrderNO[100];\r
917 VOID *StartOpCodeHandle;\r
918 VOID *EndOpCodeHandle;\r
919 VOID *OptionsOpCodeHandle;\r
920 EFI_IFR_GUID_LABEL *StartLabel;\r
921 EFI_IFR_GUID_LABEL *EndLabel;\r
922\r
923 //\r
924 // Following code will be run if user select 'order ... priority' item in second page\r
925 // Prepare third page. In third page, user will order the drivers priority which are selected in second page\r
926 //\r
927 mCurrentPage = FORM_ID_ORDER;\r
928\r
929 //\r
930 // Init OpCode Handle\r
931 //\r
932 StartOpCodeHandle = HiiAllocateOpCodeHandle ();\r
933 ASSERT (StartOpCodeHandle != NULL);\r
934\r
935 EndOpCodeHandle = HiiAllocateOpCodeHandle ();\r
936 ASSERT (EndOpCodeHandle != NULL);\r
937\r
938 //\r
939 // Create Hii Extend Label OpCode as the start opcode\r
940 //\r
941 StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (StartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));\r
942 StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;\r
943 StartLabel->Number = FORM_ID_ORDER;\r
944\r
945 //\r
946 // Create Hii Extend Label OpCode as the end opcode\r
947 //\r
948 EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (EndOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));\r
949 EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;\r
950 EndLabel->Number = LABEL_END;\r
951\r
952 //\r
953 // Clear third page form\r
954 //\r
955 HiiUpdateForm (\r
956 Private->RegisteredHandle,\r
957 &gPlatformOverridesManagerGuid,\r
958 FORM_ID_ORDER,\r
959 StartOpCodeHandle,\r
960 EndOpCodeHandle\r
961 );\r
962\r
963 //\r
964 // Check how many drivers have been selected\r
965 //\r
966 SelectedDriverImageNum = 0;\r
967 for (Index = 0; Index < mDriverImageHandleCount; Index++) {\r
968 if (mDriSelection[Index]) {\r
969 SelectedDriverImageNum ++;\r
970 }\r
971 }\r
972\r
973 mSelectedDriverImageNum = SelectedDriverImageNum;\r
974 if (SelectedDriverImageNum == 0) {\r
975 return EFI_SUCCESS;\r
976 }\r
977\r
978 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();\r
979 ASSERT (OptionsOpCodeHandle != NULL);\r
980\r
981 //\r
982 // Create order list for those selected drivers\r
983 //\r
984 SelectedDriverImageNum = 0;\r
985 for (Index = 0; Index < mDriverImageHandleCount; Index++) {\r
986 if (mDriSelection[Index]) {\r
987 //\r
988 // Use the NO. in driver binding buffer as value, will use it later\r
989 //\r
990 HiiCreateOneOfOptionOpCode (\r
991 OptionsOpCodeHandle,\r
992 mDriverImageToken[Index],\r
993 0,\r
994 EFI_IFR_NUMERIC_SIZE_1,\r
995 Index + 1\r
996 );\r
997\r
998 //\r
999 // Get the EFI Loaded Image Device Path Protocol\r
1000 //\r
1001 LoadedImageDevicePath = NULL;\r
1002 gBS->HandleProtocol (\r
1003 mDriverImageHandleBuffer[Index],\r
1004 &gEfiLoadedImageDevicePathProtocolGuid,\r
1005 (VOID **) &LoadedImageDevicePath\r
1006 );\r
1007 ASSERT (LoadedImageDevicePath != NULL);\r
1008\r
1009 //\r
1010 // Check the driver DriverImage's order number in mapping database\r
1011 //\r
1012 DriverImageNO = 0;\r
1013 CheckMapping (\r
1014 mControllerDevicePathProtocol[mSelectedCtrIndex],\r
1015 LoadedImageDevicePath,\r
1016 &mMappingDataBase,\r
1017 NULL,\r
1018 &DriverImageNO\r
1019 );\r
1020 if (DriverImageNO == 0) {\r
1021 DriverImageNO = (UINT32) mLastSavedDriverImageNum + 1;\r
1022 mLastSavedDriverImageNum++;\r
1023 }\r
1024 TempNO[SelectedDriverImageNum] = DriverImageNO;\r
1025 OrderNO[SelectedDriverImageNum] = Index + 1;\r
1026 SelectedDriverImageNum ++;\r
1027 }\r
1028 }\r
1029\r
1030 ASSERT (SelectedDriverImageNum == mSelectedDriverImageNum);\r
1031 //\r
1032 // NvRamMap Must be clear firstly\r
1033 //\r
1034 ZeroMem (FakeNvData->DriOrder, sizeof (FakeNvData->DriOrder));\r
1035\r
1036 //\r
1037 // Order the selected drivers according to the info already in mapping database\r
1038 // the less order number in mapping database the less order number in NvRamMap\r
1039 //\r
1040 for (Index=0; Index < SelectedDriverImageNum; Index++) {\r
1041 //\r
1042 // Find the minimal order number in TempNO array, its index in TempNO is same as IfrOptionList array\r
1043 //\r
1044 MinNO = 0;\r
1045 for (Index1=0; Index1 < SelectedDriverImageNum; Index1++) {\r
1046 if (TempNO[Index1] < TempNO[MinNO]) {\r
1047 MinNO = Index1;\r
1048 }\r
1049 }\r
1050 //\r
1051 // the IfrOptionList[MinNO].Value = the driver NO. in driver binding buffer\r
1052 //\r
1053 FakeNvData->DriOrder[Index] = (UINT8) OrderNO[MinNO];\r
1054 TempNO[MinNO] = MAX_CHOICE_NUM + 1;\r
1055 }\r
1056 \r
1057 //\r
1058 // Create Order List OpCode\r
1059 //\r
1060 HiiCreateOrderedListOpCode (\r
1061 StartOpCodeHandle,\r
1062 (UINT16) DRIVER_ORDER_QUESTION_ID,\r
1063 VARSTORE_ID_PLAT_OVER_MNGR,\r
1064 (UINT16) DRIVER_ORDER_VAR_OFFSET,\r
1065 mControllerToken[mSelectedCtrIndex],\r
1066 mControllerToken[mSelectedCtrIndex],\r
1067 EFI_IFR_FLAG_RESET_REQUIRED,\r
1068 0,\r
1069 EFI_IFR_NUMERIC_SIZE_1,\r
1070 (UINT8) MAX_CHOICE_NUM,\r
1071 OptionsOpCodeHandle,\r
1072 NULL\r
1073 );\r
1074\r
1075 //\r
1076 // Update third page form\r
1077 //\r
1078 HiiUpdateForm (\r
1079 Private->RegisteredHandle,\r
1080 &gPlatformOverridesManagerGuid,\r
1081 FORM_ID_ORDER,\r
1082 StartOpCodeHandle, // Label FORM_ID_ORDER\r
1083 EndOpCodeHandle // LABEL_END\r
1084 );\r
1085\r
1086 HiiFreeOpCodeHandle (StartOpCodeHandle);\r
1087 HiiFreeOpCodeHandle (EndOpCodeHandle);\r
1088 HiiFreeOpCodeHandle (OptionsOpCodeHandle);\r
1089\r
1090 return EFI_SUCCESS;\r
1091}\r
1092\r
1093/**\r
1094 Save the save the mapping database to NV variable.\r
1095\r
1096 @param Private Pointer to EFI_CALLBACK_INFO.\r
1097 @param KeyValue The callback key value of device controller item in first page.\r
1098 @param FakeNvData Pointer to PLAT_OVER_MNGR_DATA.\r
1099\r
1100 @retval EFI_SUCCESS Always returned.\r
1101\r
1102**/\r
1103EFI_STATUS\r
1104CommitChanges (\r
1105 IN EFI_CALLBACK_INFO *Private,\r
1106 IN UINT16 KeyValue,\r
1107 IN PLAT_OVER_MNGR_DATA *FakeNvData\r
1108 )\r
1109{\r
1110 EFI_STATUS Status;\r
1111 UINTN Index;\r
1112 UINTN SelectedDriverImageNum;\r
1113 EFI_DEVICE_PATH_PROTOCOL *LoadedImageDevicePath;\r
1114 //\r
1115 // Following code will be run if user select 'commint changes' in third page\r
1116 // user enter 'Commit Changes' to save the mapping database\r
1117 //\r
1118 DeleteDriverImage (mControllerDevicePathProtocol[mSelectedCtrIndex], NULL, &mMappingDataBase);\r
1119 for (SelectedDriverImageNum = 0; SelectedDriverImageNum < mSelectedDriverImageNum; SelectedDriverImageNum++) {\r
1120 //\r
1121 // DriOrder[SelectedDriverImageNum] = the driver NO. in driver binding buffer\r
1122 //\r
1123 Index = FakeNvData->DriOrder[SelectedDriverImageNum] - 1;\r
1124\r
1125 //\r
1126 // Get the EFI Loaded Image Device Path Protocol\r
1127 //\r
1128 LoadedImageDevicePath = NULL;\r
1129 Status = gBS->HandleProtocol (\r
1130 mDriverImageHandleBuffer[Index],\r
1131 &gEfiLoadedImageDevicePathProtocolGuid,\r
1132 (VOID **) &LoadedImageDevicePath\r
1133 );\r
1134 ASSERT (LoadedImageDevicePath != NULL);\r
1135\r
1136 InsertDriverImage (\r
1137 mControllerDevicePathProtocol[mSelectedCtrIndex],\r
1138 LoadedImageDevicePath,\r
1139 &mMappingDataBase,\r
1140 (UINT32)SelectedDriverImageNum + 1\r
1141 );\r
1142 }\r
1143 Status = SaveOverridesMapping (&mMappingDataBase);\r
1144\r
1145 return Status;\r
1146}\r
1147\r
1148/**\r
1149 This function allows a caller to extract the current configuration for one\r
1150 or more named elements from the target driver.\r
1151\r
1152 @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.\r
1153 @param Request A null-terminated Unicode string in <ConfigRequest> format.\r
1154 @param Progress On return, points to a character in the Request string.\r
1155 Points to the string's null terminator if request was successful.\r
1156 Points to the most recent '&' before the first failing name/value\r
1157 pair (or the beginning of the string if the failure is in the\r
1158 first name/value pair) if the request was not successful.\r
1159 @param Results A null-terminated Unicode string in <ConfigAltResp> format which\r
1160 has all values filled in for the names in the Request string.\r
1161 String to be allocated by the called function.\r
1162\r
1163 @retval EFI_SUCCESS The Results is filled with the requested values.\r
1164 @retval EFI_OUT_OF_RESOURCES Not enough memory to store the results.\r
1165 @retval EFI_INVALID_PARAMETER Request is illegal syntax, or unknown name.\r
1166 @retval EFI_NOT_FOUND Routing data doesn't match any storage in this driver.\r
1167\r
1168**/\r
1169EFI_STATUS\r
1170EFIAPI\r
1171PlatOverMngrExtractConfig (\r
1172 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,\r
1173 IN CONST EFI_STRING Request,\r
1174 OUT EFI_STRING *Progress,\r
1175 OUT EFI_STRING *Results\r
1176 )\r
1177{\r
1178 EFI_STATUS Status;\r
1179 EFI_CALLBACK_INFO *Private;\r
1180 EFI_HII_CONFIG_ROUTING_PROTOCOL *HiiConfigRouting;\r
1181 EFI_STRING ConfigRequestHdr;\r
1182 EFI_STRING ConfigRequest;\r
1183 BOOLEAN AllocatedRequest;\r
1184 UINTN Size;\r
1185 UINTN BufferSize;\r
1186\r
1187 if (Progress == NULL || Results == NULL) {\r
1188 return EFI_INVALID_PARAMETER;\r
1189 }\r
1190\r
1191 *Progress = Request;\r
1192 if ((Request != NULL) && !HiiIsConfigHdrMatch (Request, &gPlatformOverridesManagerGuid, mVariableName)) {\r
1193 return EFI_NOT_FOUND;\r
1194 }\r
1195\r
1196 ConfigRequestHdr = NULL;\r
1197 ConfigRequest = NULL;\r
1198 Size = 0;\r
1199 AllocatedRequest = FALSE;\r
1200\r
1201 Private = EFI_CALLBACK_INFO_FROM_THIS (This);\r
1202 HiiConfigRouting = Private->HiiConfigRouting;\r
1203 ConfigRequest = Request;\r
1204 if ((Request == NULL) || (StrStr (Request, L"OFFSET") == NULL)) {\r
1205 //\r
1206 // Request has no request element, construct full request string.\r
1207 // Allocate and fill a buffer large enough to hold the <ConfigHdr> template\r
1208 // followed by "&OFFSET=0&WIDTH=WWWWWWWWWWWWWWWW" followed by a Null-terminator\r
1209 //\r
1210 ConfigRequestHdr = HiiConstructConfigHdr (&gPlatformOverridesManagerGuid, mVariableName, Private->DriverHandle);\r
1211 Size = (StrLen (ConfigRequestHdr) + 32 + 1) * sizeof (CHAR16);\r
1212 ConfigRequest = AllocateZeroPool (Size);\r
1213 ASSERT (ConfigRequest != NULL);\r
1214 AllocatedRequest = TRUE;\r
1215 BufferSize = sizeof (PLAT_OVER_MNGR_DATA);\r
1216 UnicodeSPrint (ConfigRequest, Size, L"%s&OFFSET=0&WIDTH=%016LX", ConfigRequestHdr, (UINT64)BufferSize);\r
1217 FreePool (ConfigRequestHdr);\r
1218 }\r
1219\r
1220 //\r
1221 // Convert buffer data to <ConfigResp> by helper function BlockToConfig()\r
1222 //\r
1223 Status = HiiConfigRouting->BlockToConfig (\r
1224 HiiConfigRouting,\r
1225 ConfigRequest,\r
1226 (UINT8 *) &Private->FakeNvData,\r
1227 sizeof (PLAT_OVER_MNGR_DATA),\r
1228 Results,\r
1229 Progress\r
1230 );\r
1231\r
1232 //\r
1233 // Free the allocated config request string.\r
1234 //\r
1235 if (AllocatedRequest) {\r
1236 FreePool (ConfigRequest);\r
1237 ConfigRequest = NULL;\r
1238 }\r
1239 //\r
1240 // Set Progress string to the original request string.\r
1241 //\r
1242 if (Request == NULL) {\r
1243 *Progress = NULL;\r
1244 } else if (StrStr (Request, L"OFFSET") == NULL) {\r
1245 *Progress = Request + StrLen (Request);\r
1246 }\r
1247\r
1248 return Status;\r
1249}\r
1250\r
1251/**\r
1252 This function processes the results of changes in configuration.\r
1253\r
1254 @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.\r
1255 @param Configuration A null-terminated Unicode string in <ConfigRequest> format.\r
1256 @param Progress A pointer to a string filled in with the offset of the most\r
1257 recent '&' before the first failing name/value pair (or the\r
1258 beginning of the string if the failure is in the first\r
1259 name/value pair) or the terminating NULL if all was successful.\r
1260\r
1261 @retval EFI_SUCCESS The Results is processed successfully.\r
1262 @retval EFI_INVALID_PARAMETER Configuration is NULL.\r
1263 @retval EFI_NOT_FOUND Routing data doesn't match any storage in this driver.\r
1264\r
1265**/\r
1266EFI_STATUS\r
1267EFIAPI\r
1268PlatOverMngrRouteConfig (\r
1269 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,\r
1270 IN CONST EFI_STRING Configuration,\r
1271 OUT EFI_STRING *Progress\r
1272 )\r
1273{\r
1274 EFI_CALLBACK_INFO *Private;\r
1275 UINT16 KeyValue;\r
1276 PLAT_OVER_MNGR_DATA *FakeNvData;\r
1277 EFI_STATUS Status;\r
1278\r
1279 if (Configuration == NULL || Progress == NULL) {\r
1280 return EFI_INVALID_PARAMETER;\r
1281 }\r
1282 *Progress = Configuration;\r
1283\r
1284 if (!HiiIsConfigHdrMatch (Configuration, &gPlatformOverridesManagerGuid, mVariableName)) {\r
1285 return EFI_NOT_FOUND;\r
1286 }\r
1287 \r
1288 *Progress = Configuration + StrLen (Configuration);\r
1289 Private = EFI_CALLBACK_INFO_FROM_THIS (This);\r
1290 FakeNvData = &Private->FakeNvData;\r
1291 if (!HiiGetBrowserData (&gPlatformOverridesManagerGuid, mVariableName, sizeof (PLAT_OVER_MNGR_DATA), (UINT8 *) FakeNvData)) {\r
1292 //\r
1293 // FakeNvData can't be got from SetupBrowser, which doesn't need to be set.\r
1294 //\r
1295 return EFI_SUCCESS;\r
1296 }\r
1297\r
1298 Status = EFI_SUCCESS;\r
1299\r
1300 if (mCurrentPage == FORM_ID_ORDER) {\r
1301 KeyValue = KEY_VALUE_ORDER_SAVE_AND_EXIT;\r
1302 Status = CommitChanges (Private, KeyValue, FakeNvData);\r
1303 }\r
1304\r
1305 return Status;\r
1306}\r
1307\r
1308/**\r
1309 This is the function that is called to provide results data to the driver. This data\r
1310 consists of a unique key which is used to identify what data is either being passed back\r
1311 or being asked for.\r
1312\r
1313 @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.\r
1314 @param Action A null-terminated Unicode string in <ConfigRequest> format.\r
1315 @param KeyValue A unique Goto OpCode callback value which record user's selection.\r
1316 0x100 <= KeyValue <0x500 : user select a controller item in the first page;\r
1317 KeyValue == 0x1234 : user select 'Refresh' in first page, or user select 'Go to Previous Menu' in second page\r
1318 KeyValue == 0x1235 : user select 'Pci device filter' in first page\r
1319 KeyValue == 0x1500 : user select 'order ... priority' item in second page\r
1320 KeyValue == 0x1800 : user select 'commint changes' in third page\r
1321 KeyValue == 0x2000 : user select 'Go to Previous Menu' in third page\r
1322 @param Type The type of value for the question.\r
1323 @param Value A pointer to the data being sent to the original exporting driver.\r
1324 @param ActionRequest On return, points to the action requested by the callback function.\r
1325\r
1326 @retval EFI_SUCCESS Always returned.\r
1327\r
1328**/\r
1329EFI_STATUS\r
1330EFIAPI\r
1331PlatOverMngrCallback (\r
1332 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,\r
1333 IN EFI_BROWSER_ACTION Action,\r
1334 IN EFI_QUESTION_ID KeyValue,\r
1335 IN UINT8 Type,\r
1336 IN EFI_IFR_TYPE_VALUE *Value,\r
1337 OUT EFI_BROWSER_ACTION_REQUEST *ActionRequest\r
1338 )\r
1339{\r
1340 EFI_CALLBACK_INFO *Private;\r
1341 EFI_STATUS Status;\r
1342 EFI_STRING_ID NewStringToken;\r
1343 EFI_INPUT_KEY Key;\r
1344 PLAT_OVER_MNGR_DATA *FakeNvData;\r
1345\r
1346 if ((Action != EFI_BROWSER_ACTION_CHANGING) && (Action != EFI_BROWSER_ACTION_CHANGED)) {\r
1347 //\r
1348 // All other action return unsupported.\r
1349 //\r
1350 return EFI_UNSUPPORTED;\r
1351 }\r
1352\r
1353 Private = EFI_CALLBACK_INFO_FROM_THIS (This);\r
1354 FakeNvData = &Private->FakeNvData;\r
1355 if (!HiiGetBrowserData (&gPlatformOverridesManagerGuid, mVariableName, sizeof (PLAT_OVER_MNGR_DATA), (UINT8 *) FakeNvData)) {\r
1356 return EFI_NOT_FOUND;\r
1357 }\r
1358\r
1359 if (Action == EFI_BROWSER_ACTION_CHANGING) {\r
1360 if (Value == NULL) {\r
1361 return EFI_INVALID_PARAMETER;\r
1362 }\r
1363 \r
1364 if (KeyValue == KEY_VALUE_DRIVER_GOTO_PREVIOUS) {\r
1365 UpdateDeviceSelectPage (Private, KeyValue, FakeNvData);\r
1366 //\r
1367 // Update page title string\r
1368 //\r
1369 NewStringToken = STRING_TOKEN (STR_TITLE);\r
1370 if (HiiSetString (Private->RegisteredHandle, NewStringToken, L"First, Select the controller by device path", NULL) == 0) {\r
1371 ASSERT (FALSE);\r
1372 }\r
1373 }\r
1374\r
1375 if (((KeyValue >= KEY_VALUE_DEVICE_OFFSET) && (KeyValue < KEY_VALUE_DEVICE_OFFSET + mMaxDeviceCount)) || (KeyValue == KEY_VALUE_ORDER_GOTO_PREVIOUS)) {\r
1376 if (KeyValue == KEY_VALUE_ORDER_GOTO_PREVIOUS) {\r
1377 KeyValue = (EFI_QUESTION_ID) (mSelectedCtrIndex + KEY_VALUE_DEVICE_OFFSET);\r
1378 }\r
1379 UpdateBindingDriverSelectPage (Private, KeyValue, FakeNvData);\r
1380 //\r
1381 // Update page title string\r
1382 //\r
1383 NewStringToken = STRING_TOKEN (STR_TITLE);\r
1384 if (HiiSetString (Private->RegisteredHandle, NewStringToken, L"Second, Select drivers for the previous selected controller", NULL) == 0) {\r
1385 ASSERT (FALSE);\r
1386 }\r
1387 }\r
1388\r
1389 if (KeyValue == KEY_VALUE_DRIVER_GOTO_ORDER) {\r
1390 UpdatePrioritySelectPage (Private, KeyValue, FakeNvData);\r
1391 //\r
1392 // Update page title string\r
1393 //\r
1394 NewStringToken = STRING_TOKEN (STR_TITLE);\r
1395 if (HiiSetString (Private->RegisteredHandle, NewStringToken, L"Finally, Set the priority order for the drivers and save them", NULL) == 0) {\r
1396 ASSERT (FALSE);\r
1397 }\r
1398 }\r
1399\r
1400 if (KeyValue == KEY_VALUE_DEVICE_CLEAR) {\r
1401 //\r
1402 // Deletes all environment variable(s) that contain the override mappings info\r
1403 //\r
1404 FreeMappingDatabase (&mMappingDataBase);\r
1405 Status = SaveOverridesMapping (&mMappingDataBase);\r
1406 UpdateDeviceSelectPage (Private, KeyValue, FakeNvData);\r
1407 }\r
1408 } else if (Action == EFI_BROWSER_ACTION_CHANGED) {\r
1409 if ((KeyValue >= KEY_VALUE_DRIVER_OFFSET) && (KeyValue < KEY_VALUE_DRIVER_OFFSET + mDriverImageHandleCount)) {\r
1410 mDriSelection[KeyValue - KEY_VALUE_DRIVER_OFFSET] = Value->b;\r
1411 } else {\r
1412 switch (KeyValue) {\r
1413 case KEY_VALUE_DEVICE_REFRESH:\r
1414 case KEY_VALUE_DEVICE_FILTER:\r
1415 UpdateDeviceSelectPage (Private, KeyValue, FakeNvData);\r
1416 //\r
1417 // Update page title string\r
1418 //\r
1419 NewStringToken = STRING_TOKEN (STR_TITLE);\r
1420 if (HiiSetString (Private->RegisteredHandle, NewStringToken, L"First, Select the controller by device path", NULL) == 0) {\r
1421 ASSERT (FALSE);\r
1422 }\r
1423 break;\r
1424 \r
1425 case KEY_VALUE_ORDER_SAVE_AND_EXIT:\r
1426 Status = CommitChanges (Private, KeyValue, FakeNvData);\r
1427 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_SUBMIT;\r
1428 if (EFI_ERROR (Status)) {\r
1429 CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, L"Single Override Info too large, Saving Error!", NULL);\r
1430 return EFI_DEVICE_ERROR;\r
1431 }\r
1432 break;\r
1433\r
1434 default:\r
1435 break;\r
1436 }\r
1437 }\r
1438 }\r
1439\r
1440 //\r
1441 // Pass changed uncommitted data back to Form Browser\r
1442 //\r
1443 HiiSetBrowserData (&gPlatformOverridesManagerGuid, mVariableName, sizeof (PLAT_OVER_MNGR_DATA), (UINT8 *) FakeNvData, NULL);\r
1444\r
1445 return EFI_SUCCESS;\r
1446}\r
1447\r
1448/**\r
1449 Retrieves the image handle of the platform override driver for a controller in the system.\r
1450\r
1451 @param This A pointer to the\r
1452 EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL instance.\r
1453 @param ControllerHandle The device handle of the controller to check if a\r
1454 driver override exists.\r
1455 @param DriverImageHandle On input, a pointer to the previous driver image\r
1456 handle returned by GetDriver(). On output, a\r
1457 pointer to the next driver image handle. Passing\r
1458 in a NULL, will return the first driver image\r
1459 handle for ControllerHandle.\r
1460\r
1461 @retval EFI_SUCCESS The driver override for ControllerHandle was\r
1462 returned in DriverImageHandle.\r
1463 @retval EFI_NOT_FOUND A driver override for ControllerHandle was not\r
1464 found.\r
1465 @retval EFI_INVALID_PARAMETER The handle specified by ControllerHandle is NULL.\r
1466 DriverImageHandle is not a handle that was returned\r
1467 on a previous call to GetDriver().\r
1468\r
1469**/\r
1470EFI_STATUS\r
1471EFIAPI\r
1472GetDriver (\r
1473 IN EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL *This,\r
1474 IN EFI_HANDLE ControllerHandle,\r
1475 IN OUT EFI_HANDLE *DriverImageHandle\r
1476 )\r
1477{\r
1478 EFI_STATUS Status;\r
1479\r
1480 //\r
1481 // Check that ControllerHandle is a valid handle\r
1482 //\r
1483 if (ControllerHandle == NULL) {\r
1484 return EFI_INVALID_PARAMETER;\r
1485 }\r
1486\r
1487 //\r
1488 // Read the environment variable(s) that contain the override mappings from Controller Device Path to\r
1489 // a set of Driver Device Paths, and initialize in memory database of the overrides that map Controller\r
1490 // Device Paths to an ordered set of Driver Device Paths and Driver Handles. This action is only performed\r
1491 // once and finished in first call.\r
1492 //\r
1493 if (!mEnvironmentVariableRead) {\r
1494 mEnvironmentVariableRead = TRUE;\r
1495\r
1496 Status = InitOverridesMapping (&mMappingDataBase);\r
1497 if (EFI_ERROR (Status)){\r
1498 DEBUG ((DEBUG_ERROR, "The status to Get Platform Driver Override Variable is %r\n", Status));\r
1499 InitializeListHead (&mMappingDataBase);\r
1500 return EFI_NOT_FOUND;\r
1501 }\r
1502 }\r
1503\r
1504 //\r
1505 // if the environment variable does not exist, just return not found\r
1506 //\r
1507 if (IsListEmpty (&mMappingDataBase)) {\r
1508 return EFI_NOT_FOUND;\r
1509 }\r
1510\r
1511 return GetDriverFromMapping (\r
1512 ControllerHandle,\r
1513 DriverImageHandle,\r
1514 &mMappingDataBase,\r
1515 mCallerImageHandle\r
1516 );\r
1517}\r
1518\r
1519/**\r
1520 Retrieves the device path of the platform override driver for a controller in the system.\r
1521 This driver doesn't support this API.\r
1522\r
1523 @param This A pointer to the EFI_PLATFORM_DRIVER_OVERRIDE_\r
1524 PROTOCOL instance. \r
1525 @param ControllerHandle The device handle of the controller to check if a driver override\r
1526 exists. \r
1527 @param DriverImagePath On input, a pointer to the previous driver device path returned by\r
1528 GetDriverPath(). On output, a pointer to the next driver\r
1529 device path. Passing in a pointer to NULL, will return the first\r
1530 driver device path for ControllerHandle.\r
1531 \r
1532 @retval EFI_UNSUPPORTED\r
1533**/\r
1534EFI_STATUS\r
1535EFIAPI\r
1536GetDriverPath (\r
1537 IN EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL *This,\r
1538 IN EFI_HANDLE ControllerHandle,\r
1539 IN OUT EFI_DEVICE_PATH_PROTOCOL **DriverImagePath\r
1540 )\r
1541{\r
1542 return EFI_UNSUPPORTED;\r
1543}\r
1544\r
1545\r
1546/**\r
1547 Used to associate a driver image handle with a device path that was returned on a prior call to the\r
1548 GetDriverPath() service. This driver image handle will then be available through the \r
1549 GetDriver() service. This driver doesn't support this API.\r
1550\r
1551 @param This A pointer to the EFI_PLATFORM_DRIVER_OVERRIDE_\r
1552 PROTOCOL instance. \r
1553 @param ControllerHandle The device handle of the controller. \r
1554 @param DriverImagePath A pointer to the driver device path that was returned in a prior\r
1555 call to GetDriverPath(). \r
1556 @param DriverImageHandle The driver image handle that was returned by LoadImage()\r
1557 when the driver specified by DriverImagePath was loaded \r
1558 into memory. \r
1559 \r
1560 @retval EFI_UNSUPPORTED\r
1561**/\r
1562EFI_STATUS\r
1563EFIAPI\r
1564DriverLoaded (\r
1565 IN EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL *This,\r
1566 IN EFI_HANDLE ControllerHandle,\r
1567 IN EFI_DEVICE_PATH_PROTOCOL *DriverImagePath,\r
1568 IN EFI_HANDLE DriverImageHandle\r
1569 )\r
1570{\r
1571 return EFI_UNSUPPORTED;\r
1572}\r
1573\r
1574/**\r
1575 The driver Entry Point. The funciton will export a disk device class formset and\r
1576 its callback function to hii database.\r
1577\r
1578 @param ImageHandle The firmware allocated handle for the EFI image.\r
1579 @param SystemTable A pointer to the EFI System Table.\r
1580\r
1581 @retval EFI_SUCCESS The entry point is executed successfully.\r
1582 @retval other Some error occurs when executing this entry point.\r
1583\r
1584**/\r
1585EFI_STATUS\r
1586EFIAPI\r
1587PlatDriOverrideDxeInit (\r
1588 IN EFI_HANDLE ImageHandle,\r
1589 IN EFI_SYSTEM_TABLE *SystemTable\r
1590 )\r
1591{\r
1592 EFI_STATUS Status;\r
1593 EFI_FORM_BROWSER2_PROTOCOL *FormBrowser2;\r
1594 VOID *Instance;\r
1595 \r
1596 //\r
1597 // There should only be one Form Configuration protocol\r
1598 //\r
1599 Status = gBS->LocateProtocol (\r
1600 &gEfiFormBrowser2ProtocolGuid,\r
1601 NULL,\r
1602 (VOID **) &FormBrowser2\r
1603 );\r
1604 if (EFI_ERROR (Status)) {\r
1605 return Status;\r
1606 }\r
1607\r
1608 //\r
1609 // According to UEFI spec, there can be at most a single instance\r
1610 // in the system of the EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL.\r
1611 // So here we check the existence.\r
1612 //\r
1613 Status = gBS->LocateProtocol (\r
1614 &gEfiPlatformDriverOverrideProtocolGuid,\r
1615 NULL,\r
1616 &Instance\r
1617 );\r
1618 //\r
1619 // If there was no error, assume there is an installation and return error\r
1620 //\r
1621 if (!EFI_ERROR (Status)) {\r
1622 return EFI_ALREADY_STARTED;\r
1623 }\r
1624 \r
1625 mCallerImageHandle = ImageHandle;\r
1626 mCallbackInfo = AllocateZeroPool (sizeof (EFI_CALLBACK_INFO));\r
1627 if (mCallbackInfo == NULL) {\r
1628 return EFI_BAD_BUFFER_SIZE;\r
1629 }\r
1630\r
1631 mCallbackInfo->Signature = EFI_CALLBACK_INFO_SIGNATURE;\r
1632 mCallbackInfo->ConfigAccess.ExtractConfig = PlatOverMngrExtractConfig;\r
1633 mCallbackInfo->ConfigAccess.RouteConfig = PlatOverMngrRouteConfig;\r
1634 mCallbackInfo->ConfigAccess.Callback = PlatOverMngrCallback;\r
1635 mCallbackInfo->PlatformDriverOverride.GetDriver = GetDriver;\r
1636 mCallbackInfo->PlatformDriverOverride.GetDriverPath = GetDriverPath;\r
1637 mCallbackInfo->PlatformDriverOverride.DriverLoaded = DriverLoaded;\r
1638\r
1639 //\r
1640 // Locate ConfigRouting protocol\r
1641 //\r
1642 Status = gBS->LocateProtocol (\r
1643 &gEfiHiiConfigRoutingProtocolGuid,\r
1644 NULL,\r
1645 (VOID **) &mCallbackInfo->HiiConfigRouting\r
1646 );\r
1647 if (EFI_ERROR (Status)) {\r
1648 goto Finish;\r
1649 }\r
1650\r
1651 //\r
1652 // Install Device Path Protocol and Config Access protocol to driver handle\r
1653 // Install Platform Driver Override Protocol to driver handle\r
1654 //\r
1655 Status = gBS->InstallMultipleProtocolInterfaces (\r
1656 &mCallbackInfo->DriverHandle,\r
1657 &gEfiDevicePathProtocolGuid,\r
1658 &mHiiVendorDevicePath,\r
1659 &gEfiHiiConfigAccessProtocolGuid,\r
1660 &mCallbackInfo->ConfigAccess,\r
1661 &gEfiPlatformDriverOverrideProtocolGuid,\r
1662 &mCallbackInfo->PlatformDriverOverride,\r
1663 NULL\r
1664 );\r
1665 if (EFI_ERROR (Status)) {\r
1666 goto Finish;\r
1667 }\r
1668\r
1669 //\r
1670 // Publish our HII data\r
1671 //\r
1672 mCallbackInfo->RegisteredHandle = HiiAddPackages (\r
1673 &gPlatformOverridesManagerGuid,\r
1674 mCallbackInfo->DriverHandle,\r
1675 VfrBin,\r
1676 PlatDriOverrideDxeStrings,\r
1677 NULL\r
1678 );\r
1679 if (mCallbackInfo->RegisteredHandle == NULL) {\r
1680 Status = EFI_OUT_OF_RESOURCES;\r
1681 goto Finish;\r
1682 }\r
1683\r
1684 //\r
1685 // Clear all the globle variable\r
1686 //\r
1687 mDriverImageHandleCount = 0;\r
1688 mCurrentPage = 0;\r
1689 \r
1690 return EFI_SUCCESS;\r
1691\r
1692Finish:\r
1693 PlatDriOverrideDxeUnload (ImageHandle);\r
1694\r
1695 return Status;\r
1696}\r
1697\r
1698/**\r
1699 Unload its installed protocol.\r
1700\r
1701 @param[in] ImageHandle Handle that identifies the image to be unloaded.\r
1702\r
1703 @retval EFI_SUCCESS The image has been unloaded.\r
1704**/\r
1705EFI_STATUS\r
1706EFIAPI\r
1707PlatDriOverrideDxeUnload (\r
1708 IN EFI_HANDLE ImageHandle\r
1709 )\r
1710{\r
1711 ASSERT (mCallbackInfo != NULL);\r
1712\r
1713 if (mCallbackInfo->DriverHandle != NULL) {\r
1714 gBS->UninstallMultipleProtocolInterfaces (\r
1715 mCallbackInfo->DriverHandle,\r
1716 &gEfiDevicePathProtocolGuid,\r
1717 &mHiiVendorDevicePath,\r
1718 &gEfiHiiConfigAccessProtocolGuid,\r
1719 &mCallbackInfo->ConfigAccess,\r
1720 &gEfiPlatformDriverOverrideProtocolGuid,\r
1721 &mCallbackInfo->PlatformDriverOverride,\r
1722 NULL\r
1723 );\r
1724 }\r
1725\r
1726 if (mCallbackInfo->RegisteredHandle != NULL) {\r
1727 HiiRemovePackages (mCallbackInfo->RegisteredHandle);\r
1728 }\r
1729\r
1730 FreePool (mCallbackInfo);\r
1731\r
1732 if (mControllerToken != NULL) {\r
1733 FreePool (mControllerToken);\r
1734 }\r
1735\r
1736 if (mControllerDevicePathProtocol != NULL) {\r
1737 FreePool (mControllerDevicePathProtocol);\r
1738 }\r
1739\r
1740 if (mDriverImageToken != NULL) {\r
1741 FreePool (mDriverImageToken);\r
1742 }\r
1743\r
1744 return EFI_SUCCESS;\r
1745}\r
EFI Development Kit II mirror for PVE