]> git.proxmox.com Git - mirror_edk2.git/blob - IntelFrameworkModulePkg/Universal/BdsDxe/DeviceMngr/DeviceManager.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Update inappropriate comments.
[mirror_edk2.git] / IntelFrameworkModulePkg / Universal / BdsDxe / DeviceMngr / DeviceManager.c
1 /** @file
2 The platform device manager reference implementation
3
4 Copyright (c) 2004 - 2010, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
9
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13 **/
14
15 #include "DeviceManager.h"
16
17 DEVICE_MANAGER_CALLBACK_DATA gDeviceManagerPrivate = {
18 DEVICE_MANAGER_CALLBACK_DATA_SIGNATURE,
19 NULL,
20 NULL,
21 NULL,
22 NULL,
23 {
24 FakeExtractConfig,
25 FakeRouteConfig,
26 DeviceManagerCallback
27 },
28 {
29 FakeExtractConfig,
30 FakeRouteConfig,
31 DriverHealthCallback
32 }
33 };
34
35 #define MAX_MAC_ADDRESS_NODE_LIST_LEN 10
36
37 EFI_GUID mDeviceManagerGuid = DEVICE_MANAGER_FORMSET_GUID;
38 EFI_GUID mDriverHealthGuid = DRIVER_HEALTH_FORMSET_GUID;
39
40 //
41 // Which Mac Address string is select
42 // it will decide what menu need to show in the NETWORK_DEVICE_FORM_ID form.
43 //
44 EFI_STRING mSelectedMacAddrString;
45
46 //
47 // Which form Id need to be show.
48 //
49 EFI_FORM_ID mNextShowFormId = DEVICE_MANAGER_FORM_ID;
50
51 //
52 // The Mac Address show in the NETWORK_DEVICE_LIST_FORM_ID
53 //
54 MAC_ADDRESS_NODE_LIST mMacDeviceList;
55
56 DEVICE_MANAGER_MENU_ITEM mDeviceManagerMenuItemTable[] = {
57 { STRING_TOKEN (STR_DISK_DEVICE), EFI_DISK_DEVICE_CLASS },
58 { STRING_TOKEN (STR_VIDEO_DEVICE), EFI_VIDEO_DEVICE_CLASS },
59 { STRING_TOKEN (STR_NETWORK_DEVICE), EFI_NETWORK_DEVICE_CLASS },
60 { STRING_TOKEN (STR_INPUT_DEVICE), EFI_INPUT_DEVICE_CLASS },
61 { STRING_TOKEN (STR_ON_BOARD_DEVICE), EFI_ON_BOARD_DEVICE_CLASS },
62 { STRING_TOKEN (STR_OTHER_DEVICE), EFI_OTHER_DEVICE_CLASS }
63 };
64
65 HII_VENDOR_DEVICE_PATH mDeviceManagerHiiVendorDevicePath = {
66 {
67 {
68 HARDWARE_DEVICE_PATH,
69 HW_VENDOR_DP,
70 {
71 (UINT8) (sizeof (VENDOR_DEVICE_PATH)),
72 (UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8)
73 }
74 },
75 //
76 // {102579A0-3686-466e-ACD8-80C087044F4A}
77 //
78 { 0x102579a0, 0x3686, 0x466e, { 0xac, 0xd8, 0x80, 0xc0, 0x87, 0x4, 0x4f, 0x4a } }
79 },
80 {
81 END_DEVICE_PATH_TYPE,
82 END_ENTIRE_DEVICE_PATH_SUBTYPE,
83 {
84 (UINT8) (END_DEVICE_PATH_LENGTH),
85 (UINT8) ((END_DEVICE_PATH_LENGTH) >> 8)
86 }
87 }
88 };
89
90 HII_VENDOR_DEVICE_PATH mDriverHealthHiiVendorDevicePath = {
91 {
92 {
93 HARDWARE_DEVICE_PATH,
94 HW_VENDOR_DP,
95 {
96 (UINT8) (sizeof (VENDOR_DEVICE_PATH)),
97 (UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8)
98 }
99 },
100 //
101 // {D8F76651-1675-4986-BED4-3824B2F1F4C8}
102 //
103 { 0xd8f76651, 0x1675, 0x4986, { 0xbe, 0xd4, 0x38, 0x24, 0xb2, 0xf1, 0xf4, 0xc8 } }
104 },
105 {
106 END_DEVICE_PATH_TYPE,
107 END_ENTIRE_DEVICE_PATH_SUBTYPE,
108 {
109 (UINT8) (END_DEVICE_PATH_LENGTH),
110 (UINT8) ((END_DEVICE_PATH_LENGTH) >> 8)
111 }
112 }
113 };
114
115 /**
116 This function is invoked if user selected a interactive opcode from Device Manager's
117 Formset. The decision by user is saved to gCallbackKey for later processing. If
118 user set VBIOS, the new value is saved to EFI variable.
119
120 @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
121 @param Action Specifies the type of action taken by the browser.
122 @param QuestionId A unique value which is sent to the original exporting driver
123 so that it can identify the type of data to expect.
124 @param Type The type of value for the question.
125 @param Value A pointer to the data being sent to the original exporting driver.
126 @param ActionRequest On return, points to the action requested by the callback function.
127
128 @retval EFI_SUCCESS The callback successfully handled the action.
129 @retval EFI_INVALID_PARAMETER The setup browser call this function with invalid parameters.
130
131 **/
132 EFI_STATUS
133 EFIAPI
134 DeviceManagerCallback (
135 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
136 IN EFI_BROWSER_ACTION Action,
137 IN EFI_QUESTION_ID QuestionId,
138 IN UINT8 Type,
139 IN EFI_IFR_TYPE_VALUE *Value,
140 OUT EFI_BROWSER_ACTION_REQUEST *ActionRequest
141 )
142 {
143 UINTN CurIndex;
144
145 if ((Action == EFI_BROWSER_ACTION_FORM_OPEN) || (Action == EFI_BROWSER_ACTION_FORM_CLOSE)) {
146 //
147 // Do nothing for UEFI OPEN/CLOSE Action
148 //
149 return EFI_SUCCESS;
150 }
151
152 if ((Value == NULL) || (ActionRequest == NULL)) {
153 return EFI_INVALID_PARAMETER;
154 }
155
156 gCallbackKey = QuestionId;
157
158 if ((QuestionId < MAX_KEY_SECTION_LEN + NETWORK_DEVICE_LIST_KEY_OFFSET) && (QuestionId >= NETWORK_DEVICE_LIST_KEY_OFFSET)) {
159 //
160 // If user select the mac address, need to record mac address string to support next form show.
161 //
162 for (CurIndex = 0; CurIndex < mMacDeviceList.CurListLen; CurIndex ++) {
163 if (mMacDeviceList.NodeList[CurIndex].QuestionId == QuestionId) {
164 mSelectedMacAddrString = HiiGetString (gDeviceManagerPrivate.HiiHandle, mMacDeviceList.NodeList[CurIndex].PromptId, NULL);
165 }
166 }
167 }
168
169 //
170 // Request to exit SendForm(), so as to switch to selected form
171 //
172 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_EXIT;
173
174 return EFI_SUCCESS;
175 }
176
177 /**
178
179 This function registers HII packages to HII database.
180
181 @retval EFI_SUCCESS HII packages for the Device Manager were registered successfully.
182 @retval EFI_OUT_OF_RESOURCES HII packages for the Device Manager failed to be registered.
183
184 **/
185 EFI_STATUS
186 InitializeDeviceManager (
187 VOID
188 )
189 {
190 EFI_STATUS Status;
191
192 //
193 // Install Device Path Protocol and Config Access protocol to driver handle
194 //
195 Status = gBS->InstallMultipleProtocolInterfaces (
196 &gDeviceManagerPrivate.DriverHandle,
197 &gEfiDevicePathProtocolGuid,
198 &mDeviceManagerHiiVendorDevicePath,
199 &gEfiHiiConfigAccessProtocolGuid,
200 &gDeviceManagerPrivate.ConfigAccess,
201 NULL
202 );
203 ASSERT_EFI_ERROR (Status);
204
205 Status = gBS->InstallMultipleProtocolInterfaces (
206 &gDeviceManagerPrivate.DriverHealthHandle,
207 &gEfiDevicePathProtocolGuid,
208 &mDriverHealthHiiVendorDevicePath,
209 &gEfiHiiConfigAccessProtocolGuid,
210 &gDeviceManagerPrivate.DriverHealthConfigAccess,
211 NULL
212 );
213 ASSERT_EFI_ERROR (Status);
214
215 mMacDeviceList.CurListLen = 0;
216 mMacDeviceList.MaxListLen = 0;
217
218 return Status;
219 }
220
221 /**
222 Extract the displayed formset for given HII handle and class guid.
223
224 @param Handle The HII handle.
225 @param SetupClassGuid The class guid specifies which form set will be displayed.
226 @param FormSetTitle Formset title string.
227 @param FormSetHelp Formset help string.
228
229 @retval TRUE The formset for given HII handle will be displayed.
230 @return FALSE The formset for given HII handle will not be displayed.
231
232 **/
233 BOOLEAN
234 ExtractDisplayedHiiFormFromHiiHandle (
235 IN EFI_HII_HANDLE Handle,
236 IN EFI_GUID *SetupClassGuid,
237 OUT EFI_STRING_ID *FormSetTitle,
238 OUT EFI_STRING_ID *FormSetHelp
239 )
240 {
241 EFI_STATUS Status;
242 UINTN BufferSize;
243 EFI_HII_PACKAGE_LIST_HEADER *HiiPackageList;
244 UINT8 *Package;
245 UINT8 *OpCodeData;
246 UINT32 Offset;
247 UINT32 Offset2;
248 UINT32 PackageListLength;
249 EFI_HII_PACKAGE_HEADER PackageHeader;
250 EFI_GUID *ClassGuid;
251 UINT8 ClassGuidNum;
252
253 ASSERT (Handle != NULL);
254 ASSERT (SetupClassGuid != NULL);
255 ASSERT (FormSetTitle != NULL);
256 ASSERT (FormSetHelp != NULL);
257
258 *FormSetTitle = 0;
259 *FormSetHelp = 0;
260 ClassGuidNum = 0;
261 ClassGuid = NULL;
262
263 //
264 // Get HII PackageList
265 //
266 BufferSize = 0;
267 HiiPackageList = NULL;
268 Status = gHiiDatabase->ExportPackageLists (gHiiDatabase, Handle, &BufferSize, HiiPackageList);
269 //
270 // Handle is a invalid handle. Check if Handle is corrupted.
271 //
272 ASSERT (Status != EFI_NOT_FOUND);
273 //
274 // The return status should always be EFI_BUFFER_TOO_SMALL as input buffer's size is 0.
275 //
276 ASSERT (Status == EFI_BUFFER_TOO_SMALL);
277
278 HiiPackageList = AllocatePool (BufferSize);
279 ASSERT (HiiPackageList != NULL);
280
281 Status = gHiiDatabase->ExportPackageLists (gHiiDatabase, Handle, &BufferSize, HiiPackageList);
282 if (EFI_ERROR (Status)) {
283 return FALSE;
284 }
285
286 //
287 // Get Form package from this HII package List
288 //
289 Offset = sizeof (EFI_HII_PACKAGE_LIST_HEADER);
290 Offset2 = 0;
291 PackageListLength = ReadUnaligned32 (&HiiPackageList->PackageLength);
292
293 while (Offset < PackageListLength) {
294 Package = ((UINT8 *) HiiPackageList) + Offset;
295 CopyMem (&PackageHeader, Package, sizeof (EFI_HII_PACKAGE_HEADER));
296
297 if (PackageHeader.Type == EFI_HII_PACKAGE_FORMS) {
298 //
299 // Search FormSet Opcode in this Form Package
300 //
301 Offset2 = sizeof (EFI_HII_PACKAGE_HEADER);
302 while (Offset2 < PackageHeader.Length) {
303 OpCodeData = Package + Offset2;
304
305 if (((EFI_IFR_OP_HEADER *) OpCodeData)->OpCode == EFI_IFR_FORM_SET_OP) {
306 if (((EFI_IFR_OP_HEADER *) OpCodeData)->Length > OFFSET_OF (EFI_IFR_FORM_SET, Flags)) {
307 //
308 // Find FormSet OpCode
309 //
310 ClassGuidNum = (UINT8) (((EFI_IFR_FORM_SET *) OpCodeData)->Flags & 0x3);
311 ClassGuid = (EFI_GUID *) (VOID *)(OpCodeData + sizeof (EFI_IFR_FORM_SET));
312 while (ClassGuidNum-- > 0) {
313 if (CompareGuid (SetupClassGuid, ClassGuid)) {
314 CopyMem (FormSetTitle, &((EFI_IFR_FORM_SET *) OpCodeData)->FormSetTitle, sizeof (EFI_STRING_ID));
315 CopyMem (FormSetHelp, &((EFI_IFR_FORM_SET *) OpCodeData)->Help, sizeof (EFI_STRING_ID));
316 FreePool (HiiPackageList);
317 return TRUE;
318 }
319 ClassGuid ++;
320 }
321 } else {
322 CopyMem (FormSetTitle, &((EFI_IFR_FORM_SET *) OpCodeData)->FormSetTitle, sizeof (EFI_STRING_ID));
323 CopyMem (FormSetHelp, &((EFI_IFR_FORM_SET *) OpCodeData)->Help, sizeof (EFI_STRING_ID));
324 FreePool (HiiPackageList);
325 return TRUE;
326 }
327 }
328
329 //
330 // Go to next opcode
331 //
332 Offset2 += ((EFI_IFR_OP_HEADER *) OpCodeData)->Length;
333 }
334 }
335
336 //
337 // Go to next package
338 //
339 Offset += PackageHeader.Length;
340 }
341
342 FreePool (HiiPackageList);
343
344 return FALSE;
345 }
346
347 /**
348 Get the mac address string from the device path.
349 if the device path has the vlan, get the vanid also.
350
351 @param MacAddressNode Device path begin with mac address
352 @param PBuffer Output string buffer contain mac address.
353
354 **/
355 BOOLEAN
356 GetMacAddressString(
357 IN MAC_ADDR_DEVICE_PATH *MacAddressNode,
358 OUT CHAR16 **PBuffer
359 )
360 {
361 UINTN HwAddressSize;
362 UINTN Index;
363 UINT8 *HwAddress;
364 EFI_DEVICE_PATH_PROTOCOL *Node;
365 UINT16 VlanId;
366 CHAR16 *String;
367 UINTN BufferLen;
368
369 VlanId = 0;
370 String = NULL;
371 ASSERT(MacAddressNode != NULL);
372
373 HwAddressSize = sizeof (EFI_MAC_ADDRESS);
374 if (MacAddressNode->IfType == 0x01 || MacAddressNode->IfType == 0x00) {
375 HwAddressSize = 6;
376 }
377
378 //
379 // The output format is MAC:XX:XX:XX:...\XXXX
380 // The size is the Number size + ":" size + Vlan size(\XXXX) + End
381 //
382 BufferLen = (4 + 2 * HwAddressSize + (HwAddressSize - 1) + 5 + 1) * sizeof (CHAR16);
383 String = AllocateZeroPool (BufferLen);
384 if (String == NULL) {
385 return FALSE;
386 }
387
388 *PBuffer = String;
389 StrCpy(String, L"MAC:");
390 String += 4;
391
392 //
393 // Convert the MAC address into a unicode string.
394 //
395 HwAddress = &MacAddressNode->MacAddress.Addr[0];
396 for (Index = 0; Index < HwAddressSize; Index++) {
397 String += UnicodeValueToString (String, PREFIX_ZERO | RADIX_HEX, *(HwAddress++), 2);
398 if (Index < HwAddressSize - 1) {
399 *String++ = L':';
400 }
401 }
402
403 //
404 // If VLAN is configured, it will need extra 5 characters like "\0005".
405 // Plus one unicode character for the null-terminator.
406 //
407 Node = (EFI_DEVICE_PATH_PROTOCOL *)MacAddressNode;
408 while (!IsDevicePathEnd (Node)) {
409 if (Node->Type == MESSAGING_DEVICE_PATH && Node->SubType == MSG_VLAN_DP) {
410 VlanId = ((VLAN_DEVICE_PATH *) Node)->VlanId;
411 }
412 Node = NextDevicePathNode (Node);
413 }
414
415 if (VlanId != 0) {
416 *String++ = L'\\';
417 String += UnicodeValueToString (String, PREFIX_ZERO | RADIX_HEX, VlanId, 4);
418 }
419
420 //
421 // Null terminate the Unicode string
422 //
423 *String = L'\0';
424
425 return TRUE;
426 }
427
428 /**
429 Save question id and prompt id to the mac device list.
430 If the same mac address has saved yet, no need to add more.
431
432 @param MacAddrString Mac address string.
433
434 @retval EFI_SUCCESS Add the item is successful.
435 @return Other values if failed to Add the item.
436 **/
437 BOOLEAN
438 AddIdToMacDeviceList (
439 IN EFI_STRING MacAddrString
440 )
441 {
442 MENU_INFO_ITEM *TempDeviceList;
443 UINTN Index;
444 EFI_STRING StoredString;
445 EFI_STRING_ID PromptId;
446 EFI_HII_HANDLE HiiHandle;
447
448 HiiHandle = gDeviceManagerPrivate.HiiHandle;
449 TempDeviceList = NULL;
450
451 for (Index = 0; Index < mMacDeviceList.CurListLen; Index ++) {
452 StoredString = HiiGetString (HiiHandle, mMacDeviceList.NodeList[Index].PromptId, NULL);
453 if (StoredString == NULL) {
454 return FALSE;
455 }
456
457 //
458 // Already has save the same mac address to the list.
459 //
460 if (StrCmp (MacAddrString, StoredString) == 0) {
461 return FALSE;
462 }
463 }
464
465 PromptId = HiiSetString(HiiHandle, 0, MacAddrString, NULL);
466 //
467 // If not in the list, save it.
468 //
469 if (mMacDeviceList.MaxListLen > mMacDeviceList.CurListLen + 1) {
470 mMacDeviceList.NodeList[mMacDeviceList.CurListLen].PromptId = PromptId;
471 mMacDeviceList.NodeList[mMacDeviceList.CurListLen].QuestionId = (EFI_QUESTION_ID) (mMacDeviceList.CurListLen + NETWORK_DEVICE_LIST_KEY_OFFSET);
472 } else {
473 mMacDeviceList.MaxListLen += MAX_MAC_ADDRESS_NODE_LIST_LEN;
474 if (mMacDeviceList.CurListLen != 0) {
475 TempDeviceList = (MENU_INFO_ITEM *)AllocateCopyPool (sizeof (MENU_INFO_ITEM) * mMacDeviceList.MaxListLen, (VOID *)mMacDeviceList.NodeList);
476 } else {
477 TempDeviceList = (MENU_INFO_ITEM *)AllocatePool (sizeof (MENU_INFO_ITEM) * mMacDeviceList.MaxListLen);
478 }
479
480 if (TempDeviceList == NULL) {
481 return FALSE;
482 }
483 TempDeviceList[mMacDeviceList.CurListLen].PromptId = PromptId;
484 TempDeviceList[mMacDeviceList.CurListLen].QuestionId = (EFI_QUESTION_ID) (mMacDeviceList.CurListLen + NETWORK_DEVICE_LIST_KEY_OFFSET);
485
486 if (mMacDeviceList.CurListLen > 0) {
487 FreePool(mMacDeviceList.NodeList);
488 }
489
490 mMacDeviceList.NodeList = TempDeviceList;
491 }
492 mMacDeviceList.CurListLen ++;
493
494 return TRUE;
495 }
496
497 /**
498 Check the devcie path, try to find whether it has mac address path.
499
500 In this function, first need to check whether this path has mac address path.
501 second, when the mac address device path has find, also need to deicide whether
502 need to add this mac address relate info to the menu.
503
504 @param *Node Input device which need to be check.
505 @param *NeedAddItem Whether need to add the menu in the network device list.
506
507 @retval TRUE Has mac address device path.
508 @retval FALSE NOT Has mac address device path.
509
510 **/
511 BOOLEAN
512 IsMacAddressDevicePath (
513 IN VOID *Node,
514 OUT BOOLEAN *NeedAddItem
515 )
516 {
517 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
518 CHAR16 *Buffer;
519 BOOLEAN ReturnVal;
520
521 ASSERT (Node != NULL);
522 *NeedAddItem = FALSE;
523 ReturnVal = FALSE;
524 Buffer = NULL;
525
526 DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) Node;
527
528 //
529 // find the partition device path node
530 //
531 while (!IsDevicePathEnd (DevicePath)) {
532 if ((DevicePathType (DevicePath) == MESSAGING_DEVICE_PATH) &&
533 (DevicePathSubType (DevicePath) == MSG_MAC_ADDR_DP)) {
534 ReturnVal = TRUE;
535
536 if (DEVICE_MANAGER_FORM_ID == mNextShowFormId) {
537 *NeedAddItem = TRUE;
538 break;
539 }
540
541 if (!GetMacAddressString((MAC_ADDR_DEVICE_PATH*)DevicePath, &Buffer)) {
542 break;
543 }
544
545 if (NETWORK_DEVICE_FORM_ID == mNextShowFormId) {
546 if (StrCmp (Buffer, mSelectedMacAddrString) == 0) {
547 *NeedAddItem = TRUE;
548 }
549 break;
550 }
551
552 if (NETWORK_DEVICE_LIST_FORM_ID == mNextShowFormId) {
553 //
554 // Same handle may has two network child handle, so the questionid
555 // has the offset of SAME_HANDLE_KEY_OFFSET.
556 //
557 if (AddIdToMacDeviceList (Buffer)) {
558 *NeedAddItem = TRUE;
559 }
560 break;
561 }
562 }
563 DevicePath = NextDevicePathNode (DevicePath);
564 }
565
566 if (Buffer != NULL) {
567 FreePool (Buffer);
568 }
569
570 return ReturnVal;
571 }
572
573 /**
574 Check to see if the device path is for the network device.
575
576 @param Handle The HII handle which include the mac address device path.
577 @param ItemCount The new add Mac address item count.
578
579 @retval TRUE Need to add new item in the menu.
580 @return FALSE Do not need to add the menu about the network.
581
582 **/
583 BOOLEAN
584 IsNeedAddNetworkMenu (
585 IN EFI_HII_HANDLE Handle,
586 OUT UINTN *ItemCount
587 )
588 {
589 EFI_STATUS Status;
590 UINTN EntryCount;
591 UINTN Index;
592 EFI_HII_HANDLE HiiDeviceManagerHandle;
593 EFI_HANDLE DriverHandle;
594 EFI_HANDLE ControllerHandle;
595 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
596 EFI_DEVICE_PATH_PROTOCOL *TmpDevicePath;
597 EFI_DEVICE_PATH_PROTOCOL *ChildDevicePath;
598 EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenInfoBuffer;
599 BOOLEAN IsNeedAdd;
600
601 HiiDeviceManagerHandle = gDeviceManagerPrivate.HiiHandle;
602 IsNeedAdd = FALSE;
603 OpenInfoBuffer = NULL;
604 if ((Handle == NULL) || (ItemCount == NULL)) {
605 return FALSE;
606 }
607 *ItemCount = 0;
608
609 Status = gHiiDatabase->GetPackageListHandle (gHiiDatabase, Handle, &DriverHandle);
610 if (EFI_ERROR (Status)) {
611 return FALSE;
612 }
613 //
614 // Get the device path by the got Driver handle .
615 //
616 Status = gBS->HandleProtocol (DriverHandle, &gEfiDevicePathProtocolGuid, (VOID **) &DevicePath);
617 if (EFI_ERROR (Status)) {
618 return FALSE;
619 }
620 TmpDevicePath = DevicePath;
621
622 //
623 // Check whether this device path include mac address device path.
624 // If this path has mac address path, get the value whether need
625 // add this info to the menu and return.
626 // Else check more about the child handle devcie path.
627 //
628 if (IsMacAddressDevicePath(TmpDevicePath, &IsNeedAdd)) {
629 if ((NETWORK_DEVICE_LIST_FORM_ID == mNextShowFormId) && IsNeedAdd) {
630 (*ItemCount) = 1;
631 }
632 return IsNeedAdd;
633 }
634
635 //
636 // Search whether this path is the controller path, not he child handle path.
637 // And the child handle has the network devcie connected.
638 //
639 TmpDevicePath = DevicePath;
640 Status = gBS->LocateDevicePath(&gEfiDevicePathProtocolGuid, &TmpDevicePath, &ControllerHandle);
641 if (EFI_ERROR (Status)) {
642 return FALSE;
643 }
644
645 if (!IsDevicePathEnd (TmpDevicePath)) {
646 return FALSE;
647 }
648
649 //
650 // Retrieve the list of agents that are consuming the specific protocol
651 // on ControllerHandle.
652 // The buffer point by OpenInfoBuffer need be free at this function.
653 //
654 Status = gBS->OpenProtocolInformation (
655 ControllerHandle,
656 &gEfiPciIoProtocolGuid,
657 &OpenInfoBuffer,
658 &EntryCount
659 );
660 if (EFI_ERROR (Status)) {
661 return FALSE;
662 }
663
664 //
665 // Inspect if ChildHandle is one of the agents.
666 //
667 Status = EFI_UNSUPPORTED;
668 for (Index = 0; Index < EntryCount; Index++) {
669 //
670 // Query all the children created by the controller handle's driver
671 //
672 if ((OpenInfoBuffer[Index].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
673 Status = gBS->OpenProtocol (
674 OpenInfoBuffer[Index].ControllerHandle,
675 &gEfiDevicePathProtocolGuid,
676 (VOID **) &ChildDevicePath,
677 NULL,
678 NULL,
679 EFI_OPEN_PROTOCOL_GET_PROTOCOL
680 );
681 if (EFI_ERROR (Status)) {
682 continue;
683 }
684
685 //
686 // Check whether this device path include mac address device path.
687 //
688 if (!IsMacAddressDevicePath(ChildDevicePath, &IsNeedAdd)) {
689 //
690 // If this path not has mac address path, check the other.
691 //
692 continue;
693 } else {
694 //
695 // If need to update the NETWORK_DEVICE_LIST_FORM, try to get more.
696 //
697 if ((NETWORK_DEVICE_LIST_FORM_ID == mNextShowFormId)) {
698 if (IsNeedAdd) {
699 (*ItemCount) += 1;
700 }
701 continue;
702 } else {
703 //
704 // If need to update other form, return whether need to add to the menu.
705 //
706 goto Done;
707 }
708 }
709 }
710 }
711
712 Done:
713 if (OpenInfoBuffer != NULL) {
714 FreePool (OpenInfoBuffer);
715 }
716 return IsNeedAdd;
717 }
718
719 /**
720 Call the browser and display the device manager to allow user
721 to configure the platform.
722
723 This function create the dynamic content for device manager. It includes
724 section header for all class of devices, one-of opcode to set VBIOS.
725
726 @retval EFI_SUCCESS Operation is successful.
727 @return Other values if failed to clean up the dynamic content from HII
728 database.
729
730 **/
731 EFI_STATUS
732 CallDeviceManager (
733 VOID
734 )
735 {
736 EFI_STATUS Status;
737 UINTN Index;
738 EFI_STRING String;
739 EFI_STRING_ID Token;
740 EFI_STRING_ID TokenHelp;
741 EFI_HII_HANDLE *HiiHandles;
742 EFI_HII_HANDLE HiiHandle;
743 EFI_STRING_ID FormSetTitle;
744 EFI_STRING_ID FormSetHelp;
745 EFI_BROWSER_ACTION_REQUEST ActionRequest;
746 VOID *StartOpCodeHandle;
747 VOID *EndOpCodeHandle;
748 EFI_IFR_GUID_LABEL *StartLabel;
749 EFI_IFR_GUID_LABEL *EndLabel;
750 UINTN NumHandles;
751 EFI_HANDLE *DriverHealthHandles;
752 BOOLEAN AddNetworkMenu;
753 UINTN AddItemCount;
754 UINTN NewStringLen;
755 EFI_STRING NewStringTitle;
756
757 HiiHandles = NULL;
758 Status = EFI_SUCCESS;
759 gCallbackKey = 0;
760 NumHandles = 0;
761 DriverHealthHandles = NULL;
762 AddNetworkMenu = FALSE;
763 AddItemCount = 0;
764
765 //
766 // Connect all prior to entering the platform setup menu.
767 //
768 if (!gConnectAllHappened) {
769 BdsLibConnectAllDriversToAllControllers ();
770 gConnectAllHappened = TRUE;
771 }
772
773 HiiHandle = gDeviceManagerPrivate.HiiHandle;
774 if (HiiHandle == NULL) {
775 //
776 // Publish our HII data.
777 //
778 HiiHandle = HiiAddPackages (
779 &mDeviceManagerGuid,
780 gDeviceManagerPrivate.DriverHandle,
781 DeviceManagerVfrBin,
782 BdsDxeStrings,
783 NULL
784 );
785 if (HiiHandle == NULL) {
786 return EFI_OUT_OF_RESOURCES;
787 }
788
789 gDeviceManagerPrivate.HiiHandle = HiiHandle;
790 }
791
792 //
793 // If need show the Network device list form, clear the old save list first.
794 //
795 if ((mNextShowFormId == NETWORK_DEVICE_LIST_FORM_ID) && (mMacDeviceList.CurListLen > 0)) {
796 mMacDeviceList.CurListLen = 0;
797 }
798
799 //
800 // Update the network device form titile.
801 //
802 if (mNextShowFormId == NETWORK_DEVICE_FORM_ID) {
803 String = HiiGetString (HiiHandle, STRING_TOKEN (STR_FORM_NETWORK_DEVICE_TITLE), NULL);
804 NewStringLen = StrLen(mSelectedMacAddrString) * 2;
805 NewStringLen += (StrLen(String) + 2) * 2;
806 NewStringTitle = AllocatePool (NewStringLen);
807 UnicodeSPrint (NewStringTitle, NewStringLen, L"%s %s", String, mSelectedMacAddrString);
808 HiiSetString (HiiHandle, STRING_TOKEN (STR_FORM_NETWORK_DEVICE_TITLE), NewStringTitle, NULL);
809 FreePool (String);
810 FreePool (NewStringTitle);
811 }
812
813 //
814 // Allocate space for creation of UpdateData Buffer
815 //
816 StartOpCodeHandle = HiiAllocateOpCodeHandle ();
817 ASSERT (StartOpCodeHandle != NULL);
818
819 EndOpCodeHandle = HiiAllocateOpCodeHandle ();
820 ASSERT (EndOpCodeHandle != NULL);
821
822 //
823 // Create Hii Extend Label OpCode as the start opcode
824 //
825 StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (StartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
826 StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
827 //
828 // According to the next show Form id(mNextShowFormId) to decide which form need to update.
829 //
830 StartLabel->Number = (UINT16) (LABEL_FORM_ID_OFFSET + mNextShowFormId);
831
832 //
833 // Create Hii Extend Label OpCode as the end opcode
834 //
835 EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (EndOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
836 EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
837 EndLabel->Number = LABEL_END;
838
839 //
840 // Get all the Hii handles
841 //
842 HiiHandles = HiiGetHiiHandles (NULL);
843 ASSERT (HiiHandles != NULL);
844
845 //
846 // Search for formset of each class type
847 //
848 for (Index = 0; HiiHandles[Index] != NULL; Index++) {
849 //
850 // The QuestionId in the form which will call the driver form has this asssumption.
851 // QuestionId = Handle Index + NETWORK_DEVICE_LIST_KEY_OFFSET;
852 // Different QuestionId at least has the section of NETWORK_DEVICE_LIST_KEY_OFFSET.
853 //
854 ASSERT(Index < MAX_KEY_SECTION_LEN);
855
856 if (!ExtractDisplayedHiiFormFromHiiHandle (HiiHandles[Index], &gEfiHiiPlatformSetupFormsetGuid, &FormSetTitle, &FormSetHelp)) {
857 continue;
858 }
859
860 String = HiiGetString (HiiHandles[Index], FormSetTitle, NULL);
861 if (String == NULL) {
862 String = HiiGetString (HiiHandle, STR_MISSING_STRING, NULL);
863 ASSERT (String != NULL);
864 }
865 Token = HiiSetString (HiiHandle, 0, String, NULL);
866 FreePool (String);
867
868 String = HiiGetString (HiiHandles[Index], FormSetHelp, NULL);
869 if (String == NULL) {
870 String = HiiGetString (HiiHandle, STR_MISSING_STRING, NULL);
871 ASSERT (String != NULL);
872 }
873 TokenHelp = HiiSetString (HiiHandle, 0, String, NULL);
874 FreePool (String);
875
876 //
877 // Network device process
878 //
879 if (IsNeedAddNetworkMenu (HiiHandles[Index], &AddItemCount)) {
880 if (mNextShowFormId == DEVICE_MANAGER_FORM_ID) {
881 //
882 // Only show one menu item "Network Config" in the device manger form.
883 //
884 if (!AddNetworkMenu) {
885 AddNetworkMenu = TRUE;
886 HiiCreateActionOpCode (
887 StartOpCodeHandle,
888 (EFI_QUESTION_ID) QUESTION_NETWORK_DEVICE_ID,
889 STRING_TOKEN (STR_FORM_NETWORK_DEVICE_LIST_TITLE),
890 STRING_TOKEN (STR_FORM_NETWORK_DEVICE_LIST_HELP),
891 EFI_IFR_FLAG_CALLBACK,
892 0
893 );
894 }
895 } else if (mNextShowFormId == NETWORK_DEVICE_LIST_FORM_ID) {
896 //
897 // In network device list form, same mac address device only show one menu.
898 //
899 while (AddItemCount > 0) {
900 HiiCreateActionOpCode (
901 StartOpCodeHandle,
902 mMacDeviceList.NodeList[mMacDeviceList.CurListLen - AddItemCount].QuestionId,
903 mMacDeviceList.NodeList[mMacDeviceList.CurListLen - AddItemCount].PromptId,
904 STRING_TOKEN (STR_NETWORK_DEVICE_HELP),
905 EFI_IFR_FLAG_CALLBACK,
906 0
907 );
908 AddItemCount -= 1;
909 }
910 } else if (mNextShowFormId == NETWORK_DEVICE_FORM_ID) {
911 //
912 // In network device form, only the selected mac address device need to be show.
913 //
914 HiiCreateActionOpCode (
915 StartOpCodeHandle,
916 (EFI_QUESTION_ID) (Index + DEVICE_KEY_OFFSET),
917 Token,
918 TokenHelp,
919 EFI_IFR_FLAG_CALLBACK,
920 0
921 );
922 }
923 } else {
924 //
925 //
926 // Not network device process, only need to show at device manger form.
927 //
928 if (mNextShowFormId == DEVICE_MANAGER_FORM_ID) {
929 HiiCreateActionOpCode (
930 StartOpCodeHandle,
931 (EFI_QUESTION_ID) (Index + DEVICE_KEY_OFFSET),
932 Token,
933 TokenHelp,
934 EFI_IFR_FLAG_CALLBACK,
935 0
936 );
937 }
938 }
939 }
940
941 Status = gBS->LocateHandleBuffer (
942 ByProtocol,
943 &gEfiDriverHealthProtocolGuid,
944 NULL,
945 &NumHandles,
946 &DriverHealthHandles
947 );
948
949 //
950 // If there are no drivers installed driver health protocol, do not create driver health entry in UI
951 //
952 if (NumHandles != 0) {
953 //
954 // If driver health protocol is installed, create Driver Health subtitle and entry
955 //
956 HiiCreateSubTitleOpCode (StartOpCodeHandle, STRING_TOKEN (STR_DM_DRIVER_HEALTH_TITLE), 0, 0, 0);
957 HiiCreateActionOpCode (
958 StartOpCodeHandle, // Container for dynamic created opcodes
959 DEVICE_MANAGER_KEY_DRIVER_HEALTH, // Question ID
960 STRING_TOKEN(STR_DRIVER_HEALTH_ALL_HEALTHY), // Prompt text
961 STRING_TOKEN(STR_DRIVER_HEALTH_STATUS_HELP), // Help text
962 EFI_IFR_FLAG_CALLBACK, // Question flag
963 0 // Action String ID
964 );
965
966 //
967 // Check All Driver health status
968 //
969 if (!PlaformHealthStatusCheck ()) {
970 //
971 // At least one driver in the platform are not in healthy status
972 //
973 HiiSetString (HiiHandle, STRING_TOKEN (STR_DRIVER_HEALTH_ALL_HEALTHY), GetStringById (STRING_TOKEN (STR_DRIVER_NOT_HEALTH)), NULL);
974 } else {
975 //
976 // For the string of STR_DRIVER_HEALTH_ALL_HEALTHY previously has been updated and we need to update it while re-entry.
977 //
978 HiiSetString (HiiHandle, STRING_TOKEN (STR_DRIVER_HEALTH_ALL_HEALTHY), GetStringById (STRING_TOKEN (STR_DRIVER_HEALTH_ALL_HEALTHY)), NULL);
979 }
980 }
981
982 HiiUpdateForm (
983 HiiHandle,
984 &mDeviceManagerGuid,
985 mNextShowFormId,
986 StartOpCodeHandle,
987 EndOpCodeHandle
988 );
989
990 ActionRequest = EFI_BROWSER_ACTION_REQUEST_NONE;
991 Status = gFormBrowser2->SendForm (
992 gFormBrowser2,
993 &HiiHandle,
994 1,
995 &mDeviceManagerGuid,
996 mNextShowFormId,
997 NULL,
998 &ActionRequest
999 );
1000 if (ActionRequest == EFI_BROWSER_ACTION_REQUEST_RESET) {
1001 EnableResetRequired ();
1002 }
1003
1004 //
1005 // We will have returned from processing a callback, selected
1006 // a target to display
1007 //
1008 if ((gCallbackKey >= DEVICE_KEY_OFFSET)) {
1009 ActionRequest = EFI_BROWSER_ACTION_REQUEST_NONE;
1010 Status = gFormBrowser2->SendForm (
1011 gFormBrowser2,
1012 &HiiHandles[gCallbackKey - DEVICE_KEY_OFFSET],
1013 1,
1014 NULL,
1015 0,
1016 NULL,
1017 &ActionRequest
1018 );
1019
1020 if (ActionRequest == EFI_BROWSER_ACTION_REQUEST_RESET) {
1021 EnableResetRequired ();
1022 }
1023
1024 //
1025 // Force return to Device Manager
1026 //
1027 gCallbackKey = FRONT_PAGE_KEY_DEVICE_MANAGER;
1028 goto Done;
1029 }
1030
1031 //
1032 // Driver Health item chose.
1033 //
1034 if (gCallbackKey == DEVICE_MANAGER_KEY_DRIVER_HEALTH) {
1035 CallDriverHealth ();
1036 //
1037 // Force return to Device Manager
1038 //
1039 gCallbackKey = FRONT_PAGE_KEY_DEVICE_MANAGER;
1040 goto Done;
1041 }
1042
1043 //
1044 // Enter from device manager and into the network device list.
1045 //
1046 if (gCallbackKey == QUESTION_NETWORK_DEVICE_ID) {
1047 mNextShowFormId = NETWORK_DEVICE_LIST_FORM_ID;
1048 gCallbackKey = FRONT_PAGE_KEY_DEVICE_MANAGER;
1049 goto Done;
1050 }
1051
1052 //
1053 // In this case, go from the network device list to the specify device.
1054 //
1055 if ((gCallbackKey < MAX_KEY_SECTION_LEN + NETWORK_DEVICE_LIST_KEY_OFFSET ) && (gCallbackKey >= NETWORK_DEVICE_LIST_KEY_OFFSET)) {
1056 mNextShowFormId = NETWORK_DEVICE_FORM_ID;
1057 gCallbackKey = FRONT_PAGE_KEY_DEVICE_MANAGER;
1058 goto Done;
1059 }
1060
1061 //
1062 // Select the ESC, the gCallbackKey == 0.
1063 //
1064 if(mNextShowFormId - 1 < DEVICE_MANAGER_FORM_ID) {
1065 mNextShowFormId = DEVICE_MANAGER_FORM_ID;
1066 } else {
1067 mNextShowFormId = (UINT16) (mNextShowFormId - 1);
1068 gCallbackKey = FRONT_PAGE_KEY_DEVICE_MANAGER;
1069 }
1070
1071 Done:
1072 //
1073 // Remove our packagelist from HII database.
1074 //
1075 HiiRemovePackages (HiiHandle);
1076 gDeviceManagerPrivate.HiiHandle = NULL;
1077
1078 HiiFreeOpCodeHandle (StartOpCodeHandle);
1079 HiiFreeOpCodeHandle (EndOpCodeHandle);
1080 FreePool (HiiHandles);
1081
1082 return Status;
1083 }
1084
1085 /**
1086 This function is invoked if user selected a interactive opcode from Driver Health's
1087 Formset. The decision by user is saved to gCallbackKey for later processing.
1088
1089 @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
1090 @param Action Specifies the type of action taken by the browser.
1091 @param QuestionId A unique value which is sent to the original exporting driver
1092 so that it can identify the type of data to expect.
1093 @param Type The type of value for the question.
1094 @param Value A pointer to the data being sent to the original exporting driver.
1095 @param ActionRequest On return, points to the action requested by the callback function.
1096
1097 @retval EFI_SUCCESS The callback successfully handled the action.
1098 @retval EFI_INVALID_PARAMETER The setup browser call this function with invalid parameters.
1099
1100 **/
1101 EFI_STATUS
1102 EFIAPI
1103 DriverHealthCallback (
1104 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
1105 IN EFI_BROWSER_ACTION Action,
1106 IN EFI_QUESTION_ID QuestionId,
1107 IN UINT8 Type,
1108 IN EFI_IFR_TYPE_VALUE *Value,
1109 OUT EFI_BROWSER_ACTION_REQUEST *ActionRequest
1110 )
1111 {
1112 if ((Action == EFI_BROWSER_ACTION_FORM_OPEN) || (Action == EFI_BROWSER_ACTION_FORM_CLOSE)) {
1113 //
1114 // Do nothing for UEFI OPEN/CLOSE Action
1115 //
1116 return EFI_SUCCESS;
1117 }
1118
1119 if ((Value == NULL) || (ActionRequest == NULL)) {
1120 return EFI_INVALID_PARAMETER;
1121 }
1122
1123 gCallbackKey = QuestionId;
1124
1125 //
1126 // Request to exit SendForm(), so as to switch to selected form
1127 //
1128 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_EXIT;
1129
1130 return EFI_SUCCESS;
1131 }
1132
1133 /**
1134 Collect and display the platform's driver health relative information, allow user to do interactive
1135 operation while the platform is unhealthy.
1136
1137 This function display a form which divided into two parts. The one list all modules which has installed
1138 driver health protocol. The list usually contain driver name, controller name, and it's health info.
1139 While the driver name can't be retrieved, will use device path as backup. The other part of the form provide
1140 a choice to the user to repair all platform.
1141
1142 **/
1143 VOID
1144 CallDriverHealth (
1145 VOID
1146 )
1147 {
1148 EFI_STATUS Status;
1149 EFI_HII_HANDLE HiiHandle;
1150 EFI_BROWSER_ACTION_REQUEST ActionRequest;
1151 EFI_IFR_GUID_LABEL *StartLabel;
1152 EFI_IFR_GUID_LABEL *StartLabelRepair;
1153 EFI_IFR_GUID_LABEL *EndLabel;
1154 EFI_IFR_GUID_LABEL *EndLabelRepair;
1155 VOID *StartOpCodeHandle;
1156 VOID *EndOpCodeHandle;
1157 VOID *StartOpCodeHandleRepair;
1158 VOID *EndOpCodeHandleRepair;
1159 UINTN Index;
1160 EFI_STRING_ID Token;
1161 EFI_STRING_ID TokenHelp;
1162 EFI_STRING String;
1163 EFI_STRING TmpString;
1164 EFI_STRING DriverName;
1165 EFI_STRING ControllerName;
1166 LIST_ENTRY DriverHealthList;
1167 DRIVER_HEALTH_INFO *DriverHealthInfo;
1168 LIST_ENTRY *Link;
1169 EFI_DEVICE_PATH_PROTOCOL *DriverDevicePath;
1170 UINTN Length;
1171
1172 Index = 0;
1173 Length = 0;
1174 DriverHealthInfo = NULL;
1175 DriverDevicePath = NULL;
1176 InitializeListHead (&DriverHealthList);
1177
1178 HiiHandle = gDeviceManagerPrivate.DriverHealthHiiHandle;
1179 if (HiiHandle == NULL) {
1180 //
1181 // Publish Driver Health HII data.
1182 //
1183 HiiHandle = HiiAddPackages (
1184 &mDeviceManagerGuid,
1185 gDeviceManagerPrivate.DriverHealthHandle,
1186 DriverHealthVfrBin,
1187 BdsDxeStrings,
1188 NULL
1189 );
1190 if (HiiHandle == NULL) {
1191 return;
1192 }
1193
1194 gDeviceManagerPrivate.DriverHealthHiiHandle = HiiHandle;
1195 }
1196
1197 //
1198 // Allocate space for creation of UpdateData Buffer
1199 //
1200 StartOpCodeHandle = HiiAllocateOpCodeHandle ();
1201 ASSERT (StartOpCodeHandle != NULL);
1202
1203 EndOpCodeHandle = HiiAllocateOpCodeHandle ();
1204 ASSERT (EndOpCodeHandle != NULL);
1205
1206 StartOpCodeHandleRepair = HiiAllocateOpCodeHandle ();
1207 ASSERT (StartOpCodeHandleRepair != NULL);
1208
1209 EndOpCodeHandleRepair = HiiAllocateOpCodeHandle ();
1210 ASSERT (EndOpCodeHandleRepair != NULL);
1211
1212 //
1213 // Create Hii Extend Label OpCode as the start opcode
1214 //
1215 StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (StartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
1216 StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
1217 StartLabel->Number = LABEL_DRIVER_HEALTH;
1218
1219 //
1220 // Create Hii Extend Label OpCode as the start opcode
1221 //
1222 StartLabelRepair = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (StartOpCodeHandleRepair, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
1223 StartLabelRepair->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
1224 StartLabelRepair->Number = LABEL_DRIVER_HEALTH_REAPIR_ALL;
1225
1226 //
1227 // Create Hii Extend Label OpCode as the end opcode
1228 //
1229 EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (EndOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
1230 EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
1231 EndLabel->Number = LABEL_DRIVER_HEALTH_END;
1232
1233 //
1234 // Create Hii Extend Label OpCode as the end opcode
1235 //
1236 EndLabelRepair = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (EndOpCodeHandleRepair, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
1237 EndLabelRepair->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
1238 EndLabelRepair->Number = LABEL_DRIVER_HEALTH_REAPIR_ALL_END;
1239
1240 HiiCreateSubTitleOpCode (StartOpCodeHandle, STRING_TOKEN (STR_DH_STATUS_LIST), 0, 0, 1);
1241
1242 Status = GetAllControllersHealthStatus (&DriverHealthList);
1243 ASSERT (Status != EFI_OUT_OF_RESOURCES);
1244
1245 Link = GetFirstNode (&DriverHealthList);
1246
1247 while (!IsNull (&DriverHealthList, Link)) {
1248 DriverHealthInfo = DEVICE_MANAGER_HEALTH_INFO_FROM_LINK (Link);
1249
1250 //
1251 // Assume no line strings is longer than 512 bytes.
1252 //
1253 String = (EFI_STRING) AllocateZeroPool (0x200);
1254 ASSERT (String != NULL);
1255
1256 Status = DriverHealthGetDriverName (DriverHealthInfo->DriverHandle, &DriverName);
1257 if (EFI_ERROR (Status)) {
1258 //
1259 // Can not get the Driver name, so use the Device path
1260 //
1261 DriverDevicePath = DevicePathFromHandle (DriverHealthInfo->DriverHandle);
1262 DriverName = DevicePathToStr (DriverDevicePath);
1263 }
1264 //
1265 // Add the Driver name & Controller name into FormSetTitle string
1266 //
1267 StrnCat (String, DriverName, StrLen (DriverName));
1268
1269
1270 Status = DriverHealthGetControllerName (
1271 DriverHealthInfo->DriverHandle,
1272 DriverHealthInfo->ControllerHandle,
1273 DriverHealthInfo->ChildHandle,
1274 &ControllerName
1275 );
1276
1277 if (!EFI_ERROR (Status)) {
1278 //
1279 // Can not get the Controller name, just let it empty.
1280 //
1281 StrnCat (String, L" ", StrLen (L" "));
1282 StrnCat (String, ControllerName, StrLen (ControllerName));
1283 }
1284
1285 //
1286 // Add the message of the Module itself provided after the string item.
1287 //
1288 if ((DriverHealthInfo->MessageList != NULL) && (DriverHealthInfo->MessageList->StringId != 0)) {
1289 StrnCat (String, L" ", StrLen (L" "));
1290 TmpString = HiiGetString (
1291 DriverHealthInfo->MessageList->HiiHandle,
1292 DriverHealthInfo->MessageList->StringId,
1293 NULL
1294 );
1295 //
1296 // Assert if can not retrieve the message string
1297 //
1298 ASSERT (TmpString != NULL);
1299 StrnCat (String, TmpString, StrLen (TmpString));
1300 FreePool (TmpString);
1301 } else {
1302 //
1303 // Update the string will be displayed base on the driver's health status
1304 //
1305 switch(DriverHealthInfo->HealthStatus) {
1306 case EfiDriverHealthStatusRepairRequired:
1307 Length = StrLen (GetStringById (STRING_TOKEN (STR_REPAIR_REQUIRED)));
1308 StrnCat (String, GetStringById (STRING_TOKEN (STR_REPAIR_REQUIRED)), Length);
1309 break;
1310 case EfiDriverHealthStatusConfigurationRequired:
1311 Length = StrLen (GetStringById (STRING_TOKEN (STR_CONFIGURATION_REQUIRED)));
1312 StrnCat (String, GetStringById (STRING_TOKEN (STR_CONFIGURATION_REQUIRED)), Length);
1313 break;
1314 case EfiDriverHealthStatusFailed:
1315 Length = StrLen (GetStringById (STRING_TOKEN (STR_OPERATION_FAILED)));
1316 StrnCat (String, GetStringById (STRING_TOKEN (STR_OPERATION_FAILED)), Length);
1317 break;
1318 case EfiDriverHealthStatusReconnectRequired:
1319 Length = StrLen (GetStringById (STRING_TOKEN (STR_RECONNECT_REQUIRED)));
1320 StrnCat (String, GetStringById (STRING_TOKEN (STR_RECONNECT_REQUIRED)), Length);
1321 break;
1322 case EfiDriverHealthStatusRebootRequired:
1323 Length = StrLen (GetStringById (STRING_TOKEN (STR_REBOOT_REQUIRED)));
1324 StrnCat (String, GetStringById (STRING_TOKEN (STR_REBOOT_REQUIRED)), Length);
1325 break;
1326 default:
1327 Length = StrLen (GetStringById (STRING_TOKEN (STR_DRIVER_HEALTH_HEALTHY)));
1328 StrnCat (String, GetStringById (STRING_TOKEN (STR_DRIVER_HEALTH_HEALTHY)), Length);
1329 break;
1330 }
1331 }
1332
1333 Token = HiiSetString (HiiHandle, 0, String, NULL);
1334 FreePool (String);
1335
1336 TokenHelp = HiiSetString (HiiHandle, 0, GetStringById( STRING_TOKEN (STR_DH_REPAIR_SINGLE_HELP)), NULL);
1337
1338 HiiCreateActionOpCode (
1339 StartOpCodeHandle,
1340 (EFI_QUESTION_ID) (Index + DRIVER_HEALTH_KEY_OFFSET),
1341 Token,
1342 TokenHelp,
1343 EFI_IFR_FLAG_CALLBACK,
1344 0
1345 );
1346 Index++;
1347 Link = GetNextNode (&DriverHealthList, Link);
1348 }
1349
1350 //
1351 // Add End Opcode for Subtitle
1352 //
1353 HiiCreateEndOpCode (StartOpCodeHandle);
1354
1355 HiiCreateSubTitleOpCode (StartOpCodeHandleRepair, STRING_TOKEN (STR_DRIVER_HEALTH_REPAIR_ALL), 0, 0, 1);
1356 TokenHelp = HiiSetString (HiiHandle, 0, GetStringById( STRING_TOKEN (STR_DH_REPAIR_ALL_HELP)), NULL);
1357
1358 if (PlaformHealthStatusCheck ()) {
1359 //
1360 // No action need to do for the platform
1361 //
1362 Token = HiiSetString (HiiHandle, 0, GetStringById( STRING_TOKEN (STR_DRIVER_HEALTH_ALL_HEALTHY)), NULL);
1363 HiiCreateActionOpCode (
1364 StartOpCodeHandleRepair,
1365 0,
1366 Token,
1367 TokenHelp,
1368 EFI_IFR_FLAG_READ_ONLY,
1369 0
1370 );
1371 } else {
1372 //
1373 // Create ActionOpCode only while the platform need to do health related operation.
1374 //
1375 Token = HiiSetString (HiiHandle, 0, GetStringById( STRING_TOKEN (STR_DH_REPAIR_ALL_TITLE)), NULL);
1376 HiiCreateActionOpCode (
1377 StartOpCodeHandleRepair,
1378 (EFI_QUESTION_ID) DRIVER_HEALTH_REPAIR_ALL_KEY,
1379 Token,
1380 TokenHelp,
1381 EFI_IFR_FLAG_CALLBACK,
1382 0
1383 );
1384 }
1385
1386 HiiCreateEndOpCode (StartOpCodeHandleRepair);
1387
1388 Status = HiiUpdateForm (
1389 HiiHandle,
1390 &mDriverHealthGuid,
1391 DRIVER_HEALTH_FORM_ID,
1392 StartOpCodeHandle,
1393 EndOpCodeHandle
1394 );
1395 ASSERT (Status != EFI_NOT_FOUND);
1396 ASSERT (Status != EFI_BUFFER_TOO_SMALL);
1397
1398 Status = HiiUpdateForm (
1399 HiiHandle,
1400 &mDriverHealthGuid,
1401 DRIVER_HEALTH_FORM_ID,
1402 StartOpCodeHandleRepair,
1403 EndOpCodeHandleRepair
1404 );
1405 ASSERT (Status != EFI_NOT_FOUND);
1406 ASSERT (Status != EFI_BUFFER_TOO_SMALL);
1407
1408 ActionRequest = EFI_BROWSER_ACTION_REQUEST_NONE;
1409 Status = gFormBrowser2->SendForm (
1410 gFormBrowser2,
1411 &HiiHandle,
1412 1,
1413 &mDriverHealthGuid,
1414 DRIVER_HEALTH_FORM_ID,
1415 NULL,
1416 &ActionRequest
1417 );
1418 if (ActionRequest == EFI_BROWSER_ACTION_REQUEST_RESET) {
1419 EnableResetRequired ();
1420 }
1421
1422 //
1423 // We will have returned from processing a callback - user either hit ESC to exit, or selected
1424 // a target to display.
1425 // Process the diver health status states here.
1426 //
1427 if (gCallbackKey >= DRIVER_HEALTH_KEY_OFFSET && gCallbackKey != DRIVER_HEALTH_REPAIR_ALL_KEY) {
1428 ActionRequest = EFI_BROWSER_ACTION_REQUEST_NONE;
1429
1430 Link = GetFirstNode (&DriverHealthList);
1431 Index = 0;
1432
1433 while (!IsNull (&DriverHealthList, Link)) {
1434 //
1435 // Got the item relative node in the List
1436 //
1437 if (Index == (gCallbackKey - DRIVER_HEALTH_KEY_OFFSET)) {
1438 DriverHealthInfo = DEVICE_MANAGER_HEALTH_INFO_FROM_LINK (Link);
1439 //
1440 // Process the driver's healthy status for the specify module
1441 //
1442 ProcessSingleControllerHealth (
1443 DriverHealthInfo->DriverHealth,
1444 DriverHealthInfo->ControllerHandle,
1445 DriverHealthInfo->ChildHandle,
1446 DriverHealthInfo->HealthStatus,
1447 &(DriverHealthInfo->MessageList),
1448 DriverHealthInfo->HiiHandle
1449 );
1450 break;
1451 }
1452 Index++;
1453 Link = GetNextNode (&DriverHealthList, Link);
1454 }
1455
1456 if (ActionRequest == EFI_BROWSER_ACTION_REQUEST_RESET) {
1457 EnableResetRequired ();
1458 }
1459
1460 //
1461 // Force return to the form of Driver Health in Device Manager
1462 //
1463 gCallbackKey = DRIVER_HEALTH_RETURN_KEY;
1464 }
1465
1466 //
1467 // Repair the whole platform
1468 //
1469 if (gCallbackKey == DRIVER_HEALTH_REPAIR_ALL_KEY) {
1470 ActionRequest = EFI_BROWSER_ACTION_REQUEST_NONE;
1471
1472 PlatformRepairAll (&DriverHealthList);
1473
1474 gCallbackKey = DRIVER_HEALTH_RETURN_KEY;
1475 }
1476
1477 //
1478 // Remove driver health packagelist from HII database.
1479 //
1480 HiiRemovePackages (HiiHandle);
1481 gDeviceManagerPrivate.DriverHealthHiiHandle = NULL;
1482
1483 //
1484 // Free driver health info list
1485 //
1486 while (!IsListEmpty (&DriverHealthList)) {
1487
1488 Link = GetFirstNode(&DriverHealthList);
1489 DriverHealthInfo = DEVICE_MANAGER_HEALTH_INFO_FROM_LINK (Link);
1490 RemoveEntryList (Link);
1491
1492 if (DriverHealthInfo->MessageList != NULL) {
1493 FreePool(DriverHealthInfo->MessageList);
1494 FreePool (DriverHealthInfo);
1495 }
1496 }
1497
1498 HiiFreeOpCodeHandle (StartOpCodeHandle);
1499 HiiFreeOpCodeHandle (EndOpCodeHandle);
1500 HiiFreeOpCodeHandle (StartOpCodeHandleRepair);
1501 HiiFreeOpCodeHandle (EndOpCodeHandleRepair);
1502
1503 if (gCallbackKey == DRIVER_HEALTH_RETURN_KEY) {
1504 //
1505 // Force return to Driver Health Form
1506 //
1507 gCallbackKey = DEVICE_MANAGER_KEY_DRIVER_HEALTH;
1508 CallDriverHealth ();
1509 }
1510 }
1511
1512
1513 /**
1514 Check the Driver Health status of a single controller and try to process it if not healthy.
1515
1516 This function called by CheckAllControllersHealthStatus () function in order to process a specify
1517 contoller's health state.
1518
1519 @param DriverHealthList A Pointer to the list contain all of the platform driver health information.
1520 @param DriverHandle The handle of driver.
1521 @param ControllerHandle The class guid specifies which form set will be displayed.
1522 @param ChildHandle The handle of the child controller to retrieve the health
1523 status on. This is an optional parameter that may be NULL.
1524 @param DriverHealth A pointer to the EFI_DRIVER_HEALTH_PROTOCOL instance.
1525 @param HealthStatus The health status of the controller.
1526
1527 @retval EFI_INVALID_PARAMETER HealthStatus or DriverHealth is NULL.
1528 @retval HealthStatus The Health status of specify controller.
1529 @retval EFI_OUT_OF_RESOURCES The list of Driver Health Protocol handles can not be retrieved.
1530 @retval EFI_NOT_FOUND No controller in the platform install Driver Health Protocol.
1531 @retval EFI_SUCCESS The Health related operation has been taken successfully.
1532
1533 **/
1534 EFI_STATUS
1535 EFIAPI
1536 GetSingleControllerHealthStatus (
1537 IN OUT LIST_ENTRY *DriverHealthList,
1538 IN EFI_HANDLE DriverHandle,
1539 IN EFI_HANDLE ControllerHandle, OPTIONAL
1540 IN EFI_HANDLE ChildHandle, OPTIONAL
1541 IN EFI_DRIVER_HEALTH_PROTOCOL *DriverHealth,
1542 IN EFI_DRIVER_HEALTH_STATUS *HealthStatus
1543 )
1544 {
1545 EFI_STATUS Status;
1546 EFI_DRIVER_HEALTH_HII_MESSAGE *MessageList;
1547 EFI_HII_HANDLE FormHiiHandle;
1548 DRIVER_HEALTH_INFO *DriverHealthInfo;
1549
1550 if (HealthStatus == NULL) {
1551 //
1552 // If HealthStatus is NULL, then return EFI_INVALID_PARAMETER
1553 //
1554 return EFI_INVALID_PARAMETER;
1555 }
1556
1557 //
1558 // Assume the HealthStatus is healthy
1559 //
1560 *HealthStatus = EfiDriverHealthStatusHealthy;
1561
1562 if (DriverHealth == NULL) {
1563 //
1564 // If DriverHealth is NULL, then return EFI_INVALID_PARAMETER
1565 //
1566 return EFI_INVALID_PARAMETER;
1567 }
1568
1569 if (ControllerHandle == NULL) {
1570 //
1571 // If ControllerHandle is NULL, the return the cumulative health status of the driver
1572 //
1573 Status = DriverHealth->GetHealthStatus (DriverHealth, NULL, NULL, HealthStatus, NULL, NULL);
1574 if (*HealthStatus == EfiDriverHealthStatusHealthy) {
1575 //
1576 // Add the driver health related information into the list
1577 //
1578 DriverHealthInfo = AllocateZeroPool (sizeof (DRIVER_HEALTH_INFO));
1579 if (DriverHealthInfo == NULL) {
1580 return EFI_OUT_OF_RESOURCES;
1581 }
1582
1583 DriverHealthInfo->Signature = DEVICE_MANAGER_DRIVER_HEALTH_INFO_SIGNATURE;
1584 DriverHealthInfo->DriverHandle = DriverHandle;
1585 DriverHealthInfo->ControllerHandle = NULL;
1586 DriverHealthInfo->ChildHandle = NULL;
1587 DriverHealthInfo->HiiHandle = NULL;
1588 DriverHealthInfo->DriverHealth = DriverHealth;
1589 DriverHealthInfo->MessageList = NULL;
1590 DriverHealthInfo->HealthStatus = *HealthStatus;
1591
1592 InsertTailList (DriverHealthList, &DriverHealthInfo->Link);
1593 }
1594 return Status;
1595 }
1596
1597 MessageList = NULL;
1598 FormHiiHandle = NULL;
1599
1600 //
1601 // Collect the health status with the optional HII message list
1602 //
1603 Status = DriverHealth->GetHealthStatus (DriverHealth, ControllerHandle, ChildHandle, HealthStatus, &MessageList, &FormHiiHandle);
1604
1605 if (EFI_ERROR (Status)) {
1606 //
1607 // If the health status could not be retrieved, then return immediately
1608 //
1609 return Status;
1610 }
1611
1612 //
1613 // Add the driver health related information into the list
1614 //
1615 DriverHealthInfo = AllocateZeroPool (sizeof (DRIVER_HEALTH_INFO));
1616 if (DriverHealthInfo == NULL) {
1617 return EFI_OUT_OF_RESOURCES;
1618 }
1619
1620 DriverHealthInfo->Signature = DEVICE_MANAGER_DRIVER_HEALTH_INFO_SIGNATURE;
1621 DriverHealthInfo->DriverHandle = DriverHandle;
1622 DriverHealthInfo->ControllerHandle = ControllerHandle;
1623 DriverHealthInfo->ChildHandle = ChildHandle;
1624 DriverHealthInfo->HiiHandle = FormHiiHandle;
1625 DriverHealthInfo->DriverHealth = DriverHealth;
1626 DriverHealthInfo->MessageList = MessageList;
1627 DriverHealthInfo->HealthStatus = *HealthStatus;
1628
1629 InsertTailList (DriverHealthList, &DriverHealthInfo->Link);
1630
1631 return EFI_SUCCESS;
1632 }
1633
1634 /**
1635 Collects all the EFI Driver Health Protocols currently present in the EFI Handle Database,
1636 and queries each EFI Driver Health Protocol to determine if one or more of the controllers
1637 managed by each EFI Driver Health Protocol instance are not healthy.
1638
1639 @param DriverHealthList A Pointer to the list contain all of the platform driver health
1640 information.
1641
1642 @retval EFI_NOT_FOUND No controller in the platform install Driver Health Protocol.
1643 @retval EFI_SUCCESS All the controllers in the platform are healthy.
1644 @retval EFI_OUT_OF_RESOURCES The list of Driver Health Protocol handles can not be retrieved.
1645
1646 **/
1647 EFI_STATUS
1648 GetAllControllersHealthStatus (
1649 IN OUT LIST_ENTRY *DriverHealthList
1650 )
1651 {
1652 EFI_STATUS Status;
1653 UINTN NumHandles;
1654 EFI_HANDLE *DriverHealthHandles;
1655 EFI_DRIVER_HEALTH_PROTOCOL *DriverHealth;
1656 EFI_DRIVER_HEALTH_STATUS HealthStatus;
1657 UINTN DriverHealthIndex;
1658 EFI_HANDLE *Handles;
1659 UINTN HandleCount;
1660 UINTN ControllerIndex;
1661 UINTN ChildIndex;
1662
1663 //
1664 // Initialize local variables
1665 //
1666 Handles = NULL;
1667 DriverHealthHandles = NULL;
1668 NumHandles = 0;
1669 HandleCount = 0;
1670
1671 HealthStatus = EfiDriverHealthStatusHealthy;
1672
1673 Status = gBS->LocateHandleBuffer (
1674 ByProtocol,
1675 &gEfiDriverHealthProtocolGuid,
1676 NULL,
1677 &NumHandles,
1678 &DriverHealthHandles
1679 );
1680
1681 if (Status == EFI_NOT_FOUND || NumHandles == 0) {
1682 //
1683 // If there are no Driver Health Protocols handles, then return EFI_NOT_FOUND
1684 //
1685 return EFI_NOT_FOUND;
1686 }
1687
1688 if (EFI_ERROR (Status) || DriverHealthHandles == NULL) {
1689 //
1690 // If the list of Driver Health Protocol handles can not be retrieved, then
1691 // return EFI_OUT_OF_RESOURCES
1692 //
1693 return EFI_OUT_OF_RESOURCES;
1694 }
1695
1696 //
1697 // Check the health status of all controllers in the platform
1698 // Start by looping through all the Driver Health Protocol handles in the handle database
1699 //
1700 for (DriverHealthIndex = 0; DriverHealthIndex < NumHandles; DriverHealthIndex++) {
1701 //
1702 // Skip NULL Driver Health Protocol handles
1703 //
1704 if (DriverHealthHandles[DriverHealthIndex] == NULL) {
1705 continue;
1706 }
1707
1708 //
1709 // Retrieve the Driver Health Protocol from DriverHandle
1710 //
1711 Status = gBS->HandleProtocol (
1712 DriverHealthHandles[DriverHealthIndex],
1713 &gEfiDriverHealthProtocolGuid,
1714 (VOID **)&DriverHealth
1715 );
1716 if (EFI_ERROR (Status)) {
1717 //
1718 // If the Driver Health Protocol can not be retrieved, then skip to the next
1719 // Driver Health Protocol handle
1720 //
1721 continue;
1722 }
1723
1724 //
1725 // Check the health of all the controllers managed by a Driver Health Protocol handle
1726 //
1727 Status = GetSingleControllerHealthStatus (DriverHealthList, DriverHealthHandles[DriverHealthIndex], NULL, NULL, DriverHealth, &HealthStatus);
1728
1729 //
1730 // If Status is an error code, then the health information could not be retrieved, so assume healthy
1731 // and skip to the next Driver Health Protocol handle
1732 //
1733 if (EFI_ERROR (Status)) {
1734 continue;
1735 }
1736
1737 //
1738 // If all the controllers managed by this Driver Health Protocol are healthy, then skip to the next
1739 // Driver Health Protocol handle
1740 //
1741 if (HealthStatus == EfiDriverHealthStatusHealthy) {
1742 continue;
1743 }
1744
1745 //
1746 // See if the list of all handles in the handle database has been retrieved
1747 //
1748 //
1749 if (Handles == NULL) {
1750 //
1751 // Retrieve the list of all handles from the handle database
1752 //
1753 Status = gBS->LocateHandleBuffer (
1754 AllHandles,
1755 NULL,
1756 NULL,
1757 &HandleCount,
1758 &Handles
1759 );
1760 if (EFI_ERROR (Status) || Handles == NULL) {
1761 //
1762 // If all the handles in the handle database can not be retrieved, then
1763 // return EFI_OUT_OF_RESOURCES
1764 //
1765 Status = EFI_OUT_OF_RESOURCES;
1766 goto Done;
1767 }
1768 }
1769 //
1770 // Loop through all the controller handles in the handle database
1771 //
1772 for (ControllerIndex = 0; ControllerIndex < HandleCount; ControllerIndex++) {
1773 //
1774 // Skip NULL controller handles
1775 //
1776 if (Handles[ControllerIndex] == NULL) {
1777 continue;
1778 }
1779
1780 Status = GetSingleControllerHealthStatus (DriverHealthList, DriverHealthHandles[DriverHealthIndex], Handles[ControllerIndex], NULL, DriverHealth, &HealthStatus);
1781 if (EFI_ERROR (Status)) {
1782 //
1783 // If Status is an error code, then the health information could not be retrieved, so assume healthy
1784 //
1785 HealthStatus = EfiDriverHealthStatusHealthy;
1786 }
1787
1788 //
1789 // If CheckHealthSingleController() returned an error on a terminal state, then do not check the health of child controllers
1790 //
1791 if (EFI_ERROR (Status)) {
1792 continue;
1793 }
1794
1795 //
1796 // Loop through all the child handles in the handle database
1797 //
1798 for (ChildIndex = 0; ChildIndex < HandleCount; ChildIndex++) {
1799 //
1800 // Skip NULL child handles
1801 //
1802 if (Handles[ChildIndex] == NULL) {
1803 continue;
1804 }
1805
1806 Status = GetSingleControllerHealthStatus (DriverHealthList, DriverHealthHandles[DriverHealthIndex], Handles[ControllerIndex], Handles[ChildIndex], DriverHealth, &HealthStatus);
1807 if (EFI_ERROR (Status)) {
1808 //
1809 // If Status is an error code, then the health information could not be retrieved, so assume healthy
1810 //
1811 HealthStatus = EfiDriverHealthStatusHealthy;
1812 }
1813
1814 //
1815 // If CheckHealthSingleController() returned an error on a terminal state, then skip to the next child
1816 //
1817 if (EFI_ERROR (Status)) {
1818 continue;
1819 }
1820 }
1821 }
1822 }
1823
1824 Status = EFI_SUCCESS;
1825
1826 Done:
1827 if (Handles != NULL) {
1828 gBS->FreePool (Handles);
1829 }
1830 if (DriverHealthHandles != NULL) {
1831 gBS->FreePool (DriverHealthHandles);
1832 }
1833
1834 return Status;
1835 }
1836
1837
1838 /**
1839 Check the healthy status of the platform, this function will return immediately while found one driver
1840 in the platform are not healthy.
1841
1842 @retval FALSE at least one driver in the platform are not healthy.
1843 @retval TRUE No controller install Driver Health Protocol,
1844 or all controllers in the platform are in healthy status.
1845 **/
1846 BOOLEAN
1847 PlaformHealthStatusCheck (
1848 VOID
1849 )
1850 {
1851 EFI_DRIVER_HEALTH_STATUS HealthStatus;
1852 EFI_STATUS Status;
1853 UINTN Index;
1854 UINTN NoHandles;
1855 EFI_HANDLE *DriverHealthHandles;
1856 EFI_DRIVER_HEALTH_PROTOCOL *DriverHealth;
1857 BOOLEAN AllHealthy;
1858
1859 //
1860 // Initialize local variables
1861 //
1862 DriverHealthHandles = NULL;
1863 DriverHealth = NULL;
1864
1865 HealthStatus = EfiDriverHealthStatusHealthy;
1866
1867 Status = gBS->LocateHandleBuffer (
1868 ByProtocol,
1869 &gEfiDriverHealthProtocolGuid,
1870 NULL,
1871 &NoHandles,
1872 &DriverHealthHandles
1873 );
1874 //
1875 // There are no handles match the search for Driver Health Protocol has been installed.
1876 //
1877 if (Status == EFI_NOT_FOUND) {
1878 return TRUE;
1879 }
1880 //
1881 // Assume all modules are healthy.
1882 //
1883 AllHealthy = TRUE;
1884
1885 //
1886 // Found one or more Handles.
1887 //
1888 if (!EFI_ERROR (Status)) {
1889 for (Index = 0; Index < NoHandles; Index++) {
1890 Status = gBS->HandleProtocol (
1891 DriverHealthHandles[Index],
1892 &gEfiDriverHealthProtocolGuid,
1893 (VOID **) &DriverHealth
1894 );
1895 if (!EFI_ERROR (Status)) {
1896 Status = DriverHealth->GetHealthStatus (
1897 DriverHealth,
1898 NULL,
1899 NULL,
1900 &HealthStatus,
1901 NULL,
1902 NULL
1903 );
1904 }
1905 //
1906 // Get the healthy status of the module
1907 //
1908 if (!EFI_ERROR (Status)) {
1909 if (HealthStatus != EfiDriverHealthStatusHealthy) {
1910 //
1911 // Return immediately one driver's status not in healthy.
1912 //
1913 return FALSE;
1914 }
1915 }
1916 }
1917 }
1918 return AllHealthy;
1919 }
1920
1921 /**
1922 Processes a single controller using the EFI Driver Health Protocol associated with
1923 that controller. This algorithm continues to query the GetHealthStatus() service until
1924 one of the legal terminal states of the EFI Driver Health Protocol is reached. This may
1925 require the processing of HII Messages, HII Form, and invocation of repair operations.
1926
1927 @param DriverHealth A pointer to the EFI_DRIVER_HEALTH_PROTOCOL instance.
1928 @param ControllerHandle The class guid specifies which form set will be displayed.
1929 @param ChildHandle The handle of the child controller to retrieve the health
1930 status on. This is an optional parameter that may be NULL.
1931 @param HealthStatus The health status of the controller.
1932 @param MessageList An array of warning or error messages associated
1933 with the controller specified by ControllerHandle and
1934 ChildHandle. This is an optional parameter that may be NULL.
1935 @param FormHiiHandle The HII handle for an HII form associated with the
1936 controller specified by ControllerHandle and ChildHandle.
1937 **/
1938 VOID
1939 ProcessSingleControllerHealth (
1940 IN EFI_DRIVER_HEALTH_PROTOCOL *DriverHealth,
1941 IN EFI_HANDLE ControllerHandle, OPTIONAL
1942 IN EFI_HANDLE ChildHandle, OPTIONAL
1943 IN EFI_DRIVER_HEALTH_STATUS HealthStatus,
1944 IN EFI_DRIVER_HEALTH_HII_MESSAGE **MessageList, OPTIONAL
1945 IN EFI_HII_HANDLE FormHiiHandle
1946 )
1947 {
1948 EFI_STATUS Status;
1949 EFI_DRIVER_HEALTH_STATUS LocalHealthStatus;
1950
1951 LocalHealthStatus = HealthStatus;
1952 //
1953 // If the module need to be repaired or reconfiguration, will process it until
1954 // reach a terminal status. The status from EfiDriverHealthStatusRepairRequired after repair
1955 // will be in (Health, Failed, Configuration Required).
1956 //
1957 while( LocalHealthStatus == EfiDriverHealthStatusConfigurationRequired ||
1958 LocalHealthStatus == EfiDriverHealthStatusRepairRequired) {
1959
1960 if (LocalHealthStatus == EfiDriverHealthStatusRepairRequired) {
1961 Status = DriverHealth->Repair (
1962 DriverHealth,
1963 ControllerHandle,
1964 ChildHandle,
1965 (EFI_DRIVER_HEALTH_REPAIR_PROGRESS_NOTIFY) RepairNotify
1966 );
1967 }
1968 //
1969 // Via a form of the driver need to do configuration provided to process of status in
1970 // EfiDriverHealthStatusConfigurationRequired. The status after configuration should be in
1971 // (Healthy, Reboot Required, Failed, Reconnect Required, Repair Required).
1972 //
1973 if (LocalHealthStatus == EfiDriverHealthStatusConfigurationRequired) {
1974 Status = gFormBrowser2->SendForm (
1975 gFormBrowser2,
1976 &FormHiiHandle,
1977 1,
1978 &gEfiHiiDriverHealthFormsetGuid,
1979 0,
1980 NULL,
1981 NULL
1982 );
1983 ASSERT( !EFI_ERROR (Status));
1984 }
1985
1986 Status = DriverHealth->GetHealthStatus (
1987 DriverHealth,
1988 ControllerHandle,
1989 ChildHandle,
1990 &LocalHealthStatus,
1991 NULL,
1992 &FormHiiHandle
1993 );
1994 ASSERT_EFI_ERROR (Status);
1995
1996 if (*MessageList != NULL) {
1997 ProcessMessages (*MessageList);
1998 }
1999 }
2000
2001 //
2002 // Health status in {Healthy, Failed} may also have Messages need to process
2003 //
2004 if (LocalHealthStatus == EfiDriverHealthStatusHealthy || LocalHealthStatus == EfiDriverHealthStatusFailed) {
2005 if (*MessageList != NULL) {
2006 ProcessMessages (*MessageList);
2007 }
2008 }
2009 //
2010 // Check for RebootRequired or ReconnectRequired
2011 //
2012 if (LocalHealthStatus == EfiDriverHealthStatusRebootRequired) {
2013 gRT->ResetSystem (EfiResetWarm, EFI_SUCCESS, 0, NULL);
2014 }
2015
2016 //
2017 // Do reconnect if need.
2018 //
2019 if (LocalHealthStatus == EfiDriverHealthStatusReconnectRequired) {
2020 Status = gBS->DisconnectController (ControllerHandle, NULL, NULL);
2021 if (EFI_ERROR (Status)) {
2022 //
2023 // Disconnect failed. Need to promote reconnect to a reboot.
2024 //
2025 gRT->ResetSystem (EfiResetWarm, EFI_SUCCESS, 0, NULL);
2026 }
2027 gBS->ConnectController (ControllerHandle, NULL, NULL, TRUE);
2028 }
2029 }
2030
2031
2032 /**
2033 Platform specific notification function for controller repair operations.
2034
2035 If the driver for a controller support the Driver Health Protocol and the
2036 current state of the controller is EfiDriverHealthStatusRepairRequired then
2037 when the Repair() service of the Driver Health Protocol is called, this
2038 platform specific notification function can display the progress of the repair
2039 operation. Some platforms may choose to not display anything, other may choose
2040 to show the percentage complete on text consoles, and other may choose to render
2041 a progress bar on text and graphical consoles.
2042
2043 This function displays the percentage of the repair operation that has been
2044 completed on text consoles. The percentage is Value / Limit * 100%.
2045
2046 @param Value Value in the range 0..Limit the the repair has completed..
2047 @param Limit The maximum value of Value
2048
2049 **/
2050 VOID
2051 RepairNotify (
2052 IN UINTN Value,
2053 IN UINTN Limit
2054 )
2055 {
2056 UINTN Percent;
2057
2058 if (Limit == 0) {
2059 Print(L"Repair Progress Undefined\n\r");
2060 } else {
2061 Percent = Value * 100 / Limit;
2062 Print(L"Repair Progress = %3d%%\n\r", Percent);
2063 }
2064 }
2065
2066 /**
2067 Processes a set of messages returned by the GetHealthStatus ()
2068 service of the EFI Driver Health Protocol
2069
2070 @param MessageList The MessageList point to messages need to processed.
2071
2072 **/
2073 VOID
2074 ProcessMessages (
2075 IN EFI_DRIVER_HEALTH_HII_MESSAGE *MessageList
2076 )
2077 {
2078 UINTN MessageIndex;
2079 EFI_STRING MessageString;
2080
2081 for (MessageIndex = 0;
2082 MessageList[MessageIndex].HiiHandle != NULL;
2083 MessageIndex++) {
2084
2085 MessageString = HiiGetString (
2086 MessageList[MessageIndex].HiiHandle,
2087 MessageList[MessageIndex].StringId,
2088 NULL
2089 );
2090 if (MessageString != NULL) {
2091 //
2092 // User can customize the output. Just simply print out the MessageString like below.
2093 // Also can use the HiiHandle to display message on the front page.
2094 //
2095 // Print(L"%s\n",MessageString);
2096 // gBS->Stall (100000);
2097 }
2098 }
2099
2100 }
2101
2102 /**
2103 Repair the whole platform.
2104
2105 This function is the main entry for user choose "Repair All" in the front page.
2106 It will try to do recovery job till all the driver health protocol installed modules
2107 reach a terminal state.
2108
2109 @param DriverHealthList A Pointer to the list contain all of the platform driver health
2110 information.
2111
2112 **/
2113 VOID
2114 PlatformRepairAll (
2115 IN LIST_ENTRY *DriverHealthList
2116 )
2117 {
2118 DRIVER_HEALTH_INFO *DriverHealthInfo;
2119 LIST_ENTRY *Link;
2120
2121 ASSERT (DriverHealthList != NULL);
2122
2123 Link = GetFirstNode (DriverHealthList);
2124
2125 while (!IsNull (DriverHealthList, Link)) {
2126 DriverHealthInfo = DEVICE_MANAGER_HEALTH_INFO_FROM_LINK (Link);
2127 //
2128 // Do driver health status operation by each link node
2129 //
2130 ASSERT (DriverHealthInfo != NULL);
2131
2132 ProcessSingleControllerHealth (
2133 DriverHealthInfo->DriverHealth,
2134 DriverHealthInfo->ControllerHandle,
2135 DriverHealthInfo->ChildHandle,
2136 DriverHealthInfo->HealthStatus,
2137 &(DriverHealthInfo->MessageList),
2138 DriverHealthInfo->HiiHandle
2139 );
2140
2141 Link = GetNextNode (DriverHealthList, Link);
2142 }
2143 }
2144
2145 /**
2146
2147 Select the best matching language according to front page policy for best user experience.
2148
2149 This function supports both ISO 639-2 and RFC 4646 language codes, but language
2150 code types may not be mixed in a single call to this function.
2151
2152 @param SupportedLanguages A pointer to a Null-terminated ASCII string that
2153 contains a set of language codes in the format
2154 specified by Iso639Language.
2155 @param Iso639Language If TRUE, then all language codes are assumed to be
2156 in ISO 639-2 format. If FALSE, then all language
2157 codes are assumed to be in RFC 4646 language format.
2158
2159 @retval NULL The best matching language could not be found in SupportedLanguages.
2160 @retval NULL There are not enough resources available to return the best matching
2161 language.
2162 @retval Other A pointer to a Null-terminated ASCII string that is the best matching
2163 language in SupportedLanguages.
2164 **/
2165 CHAR8 *
2166 DriverHealthSelectBestLanguage (
2167 IN CHAR8 *SupportedLanguages,
2168 IN BOOLEAN Iso639Language
2169 )
2170 {
2171 CHAR8 *LanguageVariable;
2172 CHAR8 *BestLanguage;
2173
2174 LanguageVariable = GetEfiGlobalVariable (Iso639Language ? L"Lang" : L"PlatformLang");
2175
2176 BestLanguage = GetBestLanguage(
2177 SupportedLanguages,
2178 Iso639Language,
2179 (LanguageVariable != NULL) ? LanguageVariable : "",
2180 Iso639Language ? "eng" : "en-US",
2181 NULL
2182 );
2183 if (LanguageVariable != NULL) {
2184 FreePool (LanguageVariable);
2185 }
2186
2187 return BestLanguage;
2188 }
2189
2190
2191
2192 /**
2193
2194 This is an internal worker function to get the Component Name (2) protocol interface
2195 and the language it supports.
2196
2197 @param ProtocolGuid A pointer to an EFI_GUID. It points to Component Name (2) protocol GUID.
2198 @param DriverBindingHandle The handle on which the Component Name (2) protocol instance is retrieved.
2199 @param ComponentName A pointer to the Component Name (2) protocol interface.
2200 @param SupportedLanguage The best suitable language that matches the SupportedLangues interface for the
2201 located Component Name (2) instance.
2202
2203 @retval EFI_SUCCESS The Component Name (2) protocol instance is successfully located and we find
2204 the best matching language it support.
2205 @retval EFI_UNSUPPORTED The input Language is not supported by the Component Name (2) protocol.
2206 @retval Other Some error occurs when locating Component Name (2) protocol instance or finding
2207 the supported language.
2208
2209 **/
2210 EFI_STATUS
2211 GetComponentNameWorker (
2212 IN EFI_GUID *ProtocolGuid,
2213 IN EFI_HANDLE DriverBindingHandle,
2214 OUT EFI_COMPONENT_NAME_PROTOCOL **ComponentName,
2215 OUT CHAR8 **SupportedLanguage
2216 )
2217 {
2218 EFI_STATUS Status;
2219
2220 //
2221 // Locate Component Name (2) protocol on the driver binging handle.
2222 //
2223 Status = gBS->OpenProtocol (
2224 DriverBindingHandle,
2225 ProtocolGuid,
2226 (VOID **) ComponentName,
2227 NULL,
2228 NULL,
2229 EFI_OPEN_PROTOCOL_GET_PROTOCOL
2230 );
2231 if (EFI_ERROR (Status)) {
2232 return Status;
2233 }
2234
2235 //
2236 // Apply shell policy to select the best language.
2237 //
2238 *SupportedLanguage = DriverHealthSelectBestLanguage (
2239 (*ComponentName)->SupportedLanguages,
2240 (BOOLEAN) (ProtocolGuid == &gEfiComponentNameProtocolGuid)
2241 );
2242 if (*SupportedLanguage == NULL) {
2243 Status = EFI_UNSUPPORTED;
2244 }
2245
2246 return Status;
2247 }
2248
2249 /**
2250
2251 This is an internal worker function to get driver name from Component Name (2) protocol interface.
2252
2253
2254 @param ProtocolGuid A pointer to an EFI_GUID. It points to Component Name (2) protocol GUID.
2255 @param DriverBindingHandle The handle on which the Component Name (2) protocol instance is retrieved.
2256 @param DriverName A pointer to the Unicode string to return. This Unicode string is the name
2257 of the driver specified by This.
2258
2259 @retval EFI_SUCCESS The driver name is successfully retrieved from Component Name (2) protocol
2260 interface.
2261 @retval Other The driver name cannot be retrieved from Component Name (2) protocol
2262 interface.
2263
2264 **/
2265 EFI_STATUS
2266 GetDriverNameWorker (
2267 IN EFI_GUID *ProtocolGuid,
2268 IN EFI_HANDLE DriverBindingHandle,
2269 OUT CHAR16 **DriverName
2270 )
2271 {
2272 EFI_STATUS Status;
2273 CHAR8 *BestLanguage;
2274 EFI_COMPONENT_NAME_PROTOCOL *ComponentName;
2275
2276 //
2277 // Retrieve Component Name (2) protocol instance on the driver binding handle and
2278 // find the best language this instance supports.
2279 //
2280 Status = GetComponentNameWorker (
2281 ProtocolGuid,
2282 DriverBindingHandle,
2283 &ComponentName,
2284 &BestLanguage
2285 );
2286 if (EFI_ERROR (Status)) {
2287 return Status;
2288 }
2289
2290 //
2291 // Get the driver name from Component Name (2) protocol instance on the driver binging handle.
2292 //
2293 Status = ComponentName->GetDriverName (
2294 ComponentName,
2295 BestLanguage,
2296 DriverName
2297 );
2298 FreePool (BestLanguage);
2299
2300 return Status;
2301 }
2302
2303 /**
2304
2305 This function gets driver name from Component Name 2 protocol interface and Component Name protocol interface
2306 in turn. It first tries UEFI 2.0 Component Name 2 protocol interface and try to get the driver name.
2307 If the attempt fails, it then gets the driver name from EFI 1.1 Component Name protocol for backward
2308 compatibility support.
2309
2310 @param DriverBindingHandle The handle on which the Component Name (2) protocol instance is retrieved.
2311 @param DriverName A pointer to the Unicode string to return. This Unicode string is the name
2312 of the driver specified by This.
2313
2314 @retval EFI_SUCCESS The driver name is successfully retrieved from Component Name (2) protocol
2315 interface.
2316 @retval Other The driver name cannot be retrieved from Component Name (2) protocol
2317 interface.
2318
2319 **/
2320 EFI_STATUS
2321 DriverHealthGetDriverName (
2322 IN EFI_HANDLE DriverBindingHandle,
2323 OUT CHAR16 **DriverName
2324 )
2325 {
2326 EFI_STATUS Status;
2327
2328 //
2329 // Get driver name from UEFI 2.0 Component Name 2 protocol interface.
2330 //
2331 Status = GetDriverNameWorker (&gEfiComponentName2ProtocolGuid, DriverBindingHandle, DriverName);
2332 if (EFI_ERROR (Status)) {
2333 //
2334 // If it fails to get the driver name from Component Name protocol interface, we should fall back on
2335 // EFI 1.1 Component Name protocol interface.
2336 //
2337 Status = GetDriverNameWorker (&gEfiComponentNameProtocolGuid, DriverBindingHandle, DriverName);
2338 }
2339
2340 return Status;
2341 }
2342
2343
2344
2345 /**
2346 This function gets controller name from Component Name 2 protocol interface and Component Name protocol interface
2347 in turn. It first tries UEFI 2.0 Component Name 2 protocol interface and try to get the controller name.
2348 If the attempt fails, it then gets the controller name from EFI 1.1 Component Name protocol for backward
2349 compatibility support.
2350
2351 @param ProtocolGuid A pointer to an EFI_GUID. It points to Component Name (2) protocol GUID.
2352 @param DriverBindingHandle The handle on which the Component Name (2) protocol instance is retrieved.
2353 @param ControllerHandle The handle of a controller that the driver specified by This is managing.
2354 This handle specifies the controller whose name is to be returned.
2355 @param ChildHandle The handle of the child controller to retrieve the name of. This is an
2356 optional parameter that may be NULL. It will be NULL for device drivers.
2357 It will also be NULL for bus drivers that attempt to retrieve the name
2358 of the bus controller. It will not be NULL for a bus driver that attempts
2359 to retrieve the name of a child controller.
2360 @param ControllerName A pointer to the Unicode string to return. This Unicode string
2361 is the name of the controller specified by ControllerHandle and ChildHandle.
2362
2363 @retval EFI_SUCCESS The controller name is successfully retrieved from Component Name (2) protocol
2364 interface.
2365 @retval Other The controller name cannot be retrieved from Component Name (2) protocol.
2366
2367 **/
2368 EFI_STATUS
2369 GetControllerNameWorker (
2370 IN EFI_GUID *ProtocolGuid,
2371 IN EFI_HANDLE DriverBindingHandle,
2372 IN EFI_HANDLE ControllerHandle,
2373 IN EFI_HANDLE ChildHandle,
2374 OUT CHAR16 **ControllerName
2375 )
2376 {
2377 EFI_STATUS Status;
2378 CHAR8 *BestLanguage;
2379 EFI_COMPONENT_NAME_PROTOCOL *ComponentName;
2380
2381 //
2382 // Retrieve Component Name (2) protocol instance on the driver binding handle and
2383 // find the best language this instance supports.
2384 //
2385 Status = GetComponentNameWorker (
2386 ProtocolGuid,
2387 DriverBindingHandle,
2388 &ComponentName,
2389 &BestLanguage
2390 );
2391 if (EFI_ERROR (Status)) {
2392 return Status;
2393 }
2394
2395 //
2396 // Get the controller name from Component Name (2) protocol instance on the driver binging handle.
2397 //
2398 Status = ComponentName->GetControllerName (
2399 ComponentName,
2400 ControllerHandle,
2401 ChildHandle,
2402 BestLanguage,
2403 ControllerName
2404 );
2405 FreePool (BestLanguage);
2406
2407 return Status;
2408 }
2409
2410 /**
2411
2412 This function gets controller name from Component Name 2 protocol interface and Component Name protocol interface
2413 in turn. It first tries UEFI 2.0 Component Name 2 protocol interface and try to get the controller name.
2414 If the attempt fails, it then gets the controller name from EFI 1.1 Component Name protocol for backward
2415 compatibility support.
2416
2417 @param DriverBindingHandle The handle on which the Component Name (2) protocol instance is retrieved.
2418 @param ControllerHandle The handle of a controller that the driver specified by This is managing.
2419 This handle specifies the controller whose name is to be returned.
2420 @param ChildHandle The handle of the child controller to retrieve the name of. This is an
2421 optional parameter that may be NULL. It will be NULL for device drivers.
2422 It will also be NULL for bus drivers that attempt to retrieve the name
2423 of the bus controller. It will not be NULL for a bus driver that attempts
2424 to retrieve the name of a child controller.
2425 @param ControllerName A pointer to the Unicode string to return. This Unicode string
2426 is the name of the controller specified by ControllerHandle and ChildHandle.
2427
2428 @retval EFI_SUCCESS The controller name is successfully retrieved from Component Name (2) protocol
2429 interface.
2430 @retval Other The controller name cannot be retrieved from Component Name (2) protocol.
2431
2432 **/
2433 EFI_STATUS
2434 DriverHealthGetControllerName (
2435 IN EFI_HANDLE DriverBindingHandle,
2436 IN EFI_HANDLE ControllerHandle,
2437 IN EFI_HANDLE ChildHandle,
2438 OUT CHAR16 **ControllerName
2439 )
2440 {
2441 EFI_STATUS Status;
2442
2443 //
2444 // Get controller name from UEFI 2.0 Component Name 2 protocol interface.
2445 //
2446 Status = GetControllerNameWorker (
2447 &gEfiComponentName2ProtocolGuid,
2448 DriverBindingHandle,
2449 ControllerHandle,
2450 ChildHandle,
2451 ControllerName
2452 );
2453 if (EFI_ERROR (Status)) {
2454 //
2455 // If it fails to get the controller name from Component Name protocol interface, we should fall back on
2456 // EFI 1.1 Component Name protocol interface.
2457 //
2458 Status = GetControllerNameWorker (
2459 &gEfiComponentNameProtocolGuid,
2460 DriverBindingHandle,
2461 ControllerHandle,
2462 ChildHandle,
2463 ControllerName
2464 );
2465 }
2466
2467 return Status;
2468 }
EFI Development Kit II mirror for PVE