]> git.proxmox.com Git - mirror_edk2.git/blame_incremental - ShellPkg/Library/UefiShellDriver1CommandsLib/Dh.c
projects / mirror_edk2.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
UefiCpuPkg: Move AsmRelocateApLoopStart from Mpfuncs.nasm to AmdSev.nasm
[mirror_edk2.git] / ShellPkg / Library / UefiShellDriver1CommandsLib / Dh.c
... / ...
CommitLineData
1/** @file\r
2 Main file for Dh shell Driver1 function.\r
3\r
4 (C) Copyright 2014-2015 Hewlett-Packard Development Company, L.P.<BR>\r
5 Copyright (c) 2010 - 2018, Intel Corporation. All rights reserved.<BR>\r
6 (C) Copyright 2017 Hewlett Packard Enterprise Development LP<BR>\r
7 SPDX-License-Identifier: BSD-2-Clause-Patent\r
8\r
9**/\r
10\r
11#include "UefiShellDriver1CommandsLib.h"\r
12\r
13STATIC CONST SHELL_PARAM_ITEM ParamList[] = {\r
14 { L"-p", TypeValue },\r
15 { L"-d", TypeFlag },\r
16 { L"-v", TypeFlag },\r
17 { L"-verbose", TypeFlag },\r
18 { L"-sfo", TypeFlag },\r
19 { L"-l", TypeValue },\r
20 { NULL, TypeMax }\r
21};\r
22\r
23STATIC CONST EFI_GUID *UefiDriverModelProtocolsGuidArray[] = {\r
24 &gEfiDriverBindingProtocolGuid,\r
25 &gEfiPlatformDriverOverrideProtocolGuid,\r
26 &gEfiBusSpecificDriverOverrideProtocolGuid,\r
27 &gEfiDriverDiagnosticsProtocolGuid,\r
28 &gEfiDriverDiagnostics2ProtocolGuid,\r
29 &gEfiComponentNameProtocolGuid,\r
30 &gEfiComponentName2ProtocolGuid,\r
31 &gEfiPlatformToDriverConfigurationProtocolGuid,\r
32 &gEfiDriverSupportedEfiVersionProtocolGuid,\r
33 &gEfiDriverFamilyOverrideProtocolGuid,\r
34 &gEfiDriverHealthProtocolGuid,\r
35 &gEfiLoadedImageProtocolGuid,\r
36 NULL\r
37};\r
38\r
39UINTN mGuidDataLen[] = { 8, 4, 4, 4, 12 };\r
40\r
41/**\r
42 Function to determine if the string can convert to a GUID.\r
43 The string must be restricted as "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" format.\r
44\r
45 @param[in] String The string to test.\r
46\r
47 @retval TRUE The string can convert to a GUID.\r
48 @retval FALSE The string can't convert to a GUID.\r
49**/\r
50BOOLEAN\r
51IsValidGuidString (\r
52 IN CONST CHAR16 *String\r
53 )\r
54{\r
55 CONST CHAR16 *Walker;\r
56 CONST CHAR16 *PrevWalker;\r
57 UINTN Index;\r
58\r
59 if (String == NULL) {\r
60 return FALSE;\r
61 }\r
62\r
63 Walker = String;\r
64 PrevWalker = String;\r
65 Index = 0;\r
66\r
67 while (Walker != NULL && *Walker != CHAR_NULL) {\r
68 if (((*Walker >= '0') && (*Walker <= '9')) ||\r
69 ((*Walker >= 'a') && (*Walker <= 'f')) ||\r
70 ((*Walker >= 'A') && (*Walker <= 'F'))\r
71 )\r
72 {\r
73 Walker++;\r
74 } else {\r
75 if ((*Walker == L'-') && ((((UINTN)Walker - (UINTN)PrevWalker) / sizeof (CHAR16)) == mGuidDataLen[Index])) {\r
76 Walker++;\r
77 PrevWalker = Walker;\r
78 Index++;\r
79 } else {\r
80 return FALSE;\r
81 }\r
82 }\r
83 }\r
84\r
85 if ((((UINTN)Walker - (UINTN)PrevWalker) / sizeof (CHAR16)) == mGuidDataLen[Index]) {\r
86 return TRUE;\r
87 } else {\r
88 return FALSE;\r
89 }\r
90}\r
91\r
92/**\r
93 Convert a hex-character to decimal value.\r
94\r
95 This internal function only deal with Unicode character\r
96 which maps to a valid hexadecimal ASII character, i.e.\r
97 L'0' to L'9', L'a' to L'f' or L'A' to L'F'. For other\r
98 Unicode character, the value returned does not make sense.\r
99\r
100 @param[in] Char The character to convert.\r
101\r
102 @retval The numerical value converted.\r
103**/\r
104UINTN\r
105HexCharToDecimal (\r
106 IN CHAR16 Char\r
107 )\r
108{\r
109 if ((Char >= '0') && (Char <= '9')) {\r
110 return Char - L'0';\r
111 } else if ((Char >= 'a') && (Char <= 'f')) {\r
112 return Char - L'a' + 10;\r
113 } else {\r
114 return Char - L'A' + 10;\r
115 }\r
116}\r
117\r
118/**\r
119 Function try to convert a string to GUID format.\r
120\r
121 @param[in] String The string will be converted.\r
122 @param[out] Guid Save the result convert from string.\r
123\r
124 @retval EFI_SUCCESS The string was successfully converted to a GUID.\r
125 @retval EFI_UNSUPPORTED The input string is not in registry format.\r
126**/\r
127EFI_STATUS\r
128ConvertStrToGuid (\r
129 IN CONST CHAR16 *String,\r
130 OUT GUID *Guid\r
131 )\r
132{\r
133 CONST CHAR16 *Walker;\r
134 UINT8 TempValue;\r
135 UINTN Index;\r
136\r
137 if ((String == NULL) || !IsValidGuidString (String)) {\r
138 return EFI_UNSUPPORTED;\r
139 }\r
140\r
141 Index = 0;\r
142\r
143 Walker = String;\r
144 Guid->Data1 = (UINT32)StrHexToUint64 (Walker);\r
145\r
146 Walker += 9;\r
147 Guid->Data2 = (UINT16)StrHexToUint64 (Walker);\r
148\r
149 Walker += 5;\r
150 Guid->Data3 = (UINT16)StrHexToUint64 (Walker);\r
151\r
152 Walker += 5;\r
153 while (Walker != NULL && *Walker != CHAR_NULL) {\r
154 if (*Walker == L'-') {\r
155 Walker++;\r
156 } else {\r
157 TempValue = (UINT8)HexCharToDecimal (*Walker);\r
158 TempValue = (UINT8)LShiftU64 (TempValue, 4);\r
159 Walker++;\r
160\r
161 TempValue += (UINT8)HexCharToDecimal (*Walker);\r
162 Walker++;\r
163\r
164 Guid->Data4[Index] = TempValue;\r
165 Index++;\r
166 }\r
167 }\r
168\r
169 return EFI_SUCCESS;\r
170}\r
171\r
172/**\r
173 Get the name of a driver by it's handle.\r
174\r
175 If a name is found the memory must be callee freed.\r
176\r
177 @param[in] TheHandle The driver's handle.\r
178 @param[in] Language The language to use.\r
179 @param[in] NameFound Upon a successful return the name found.\r
180\r
181 @retval EFI_SUCCESS The name was found.\r
182**/\r
183EFI_STATUS\r
184GetDriverName (\r
185 IN EFI_HANDLE TheHandle,\r
186 IN CONST CHAR8 *Language,\r
187 IN CHAR16 **NameFound\r
188 )\r
189{\r
190 CHAR8 *Lang;\r
191 EFI_STATUS Status;\r
192 EFI_COMPONENT_NAME2_PROTOCOL *CompName2;\r
193 CHAR16 *NameToReturn;\r
194\r
195 //\r
196 // Go through those handles until we get one that passes for GetComponentName\r
197 //\r
198 Status = gBS->OpenProtocol (\r
199 TheHandle,\r
200 &gEfiComponentName2ProtocolGuid,\r
201 (VOID **)&CompName2,\r
202 gImageHandle,\r
203 NULL,\r
204 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
205 );\r
206 if (EFI_ERROR (Status)) {\r
207 Status = gBS->OpenProtocol (\r
208 TheHandle,\r
209 &gEfiComponentNameProtocolGuid,\r
210 (VOID **)&CompName2,\r
211 gImageHandle,\r
212 NULL,\r
213 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
214 );\r
215 }\r
216\r
217 if (EFI_ERROR (Status)) {\r
218 return (EFI_NOT_FOUND);\r
219 }\r
220\r
221 Lang = GetBestLanguageForDriver (CompName2->SupportedLanguages, Language, FALSE);\r
222 Status = CompName2->GetDriverName (CompName2, Lang, &NameToReturn);\r
223 FreePool (Lang);\r
224\r
225 if (!EFI_ERROR (Status) && (NameToReturn != NULL)) {\r
226 *NameFound = NULL;\r
227 StrnCatGrow (NameFound, NULL, NameToReturn, 0);\r
228 }\r
229\r
230 return (Status);\r
231}\r
232\r
233/**\r
234 Discover if a protocol guid is one of the UEFI Driver Model Protocols.\r
235\r
236 @param[in] Guid The guid to test.\r
237\r
238 @retval TRUE The guid does represent a driver model protocol.\r
239 @retval FALSE The guid does not represent a driver model protocol.\r
240**/\r
241BOOLEAN\r
242IsDriverProt (\r
243 IN CONST EFI_GUID *Guid\r
244 )\r
245{\r
246 CONST EFI_GUID **GuidWalker;\r
247 BOOLEAN GuidFound;\r
248\r
249 GuidFound = FALSE;\r
250 for (GuidWalker = UefiDriverModelProtocolsGuidArray\r
251 ; GuidWalker != NULL && *GuidWalker != NULL\r
252 ; GuidWalker++\r
253 )\r
254 {\r
255 if (CompareGuid (*GuidWalker, Guid)) {\r
256 GuidFound = TRUE;\r
257 break;\r
258 }\r
259 }\r
260\r
261 return (GuidFound);\r
262}\r
263\r
264/**\r
265 Get information for a handle.\r
266\r
267 @param[in] TheHandle The handles to show info on.\r
268 @param[in] Language Language string per UEFI specification.\r
269 @param[in] Separator Separator string between information blocks.\r
270 @param[in] Verbose TRUE for extra info, FALSE otherwise.\r
271 @param[in] ExtraInfo TRUE for extra info, FALSE otherwise.\r
272\r
273 @retval SHELL_SUCCESS The operation was successful.\r
274 @retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.\r
275**/\r
276CHAR16 *\r
277GetProtocolInfoString (\r
278 IN CONST EFI_HANDLE TheHandle,\r
279 IN CONST CHAR8 *Language,\r
280 IN CONST CHAR16 *Separator,\r
281 IN CONST BOOLEAN Verbose,\r
282 IN CONST BOOLEAN ExtraInfo\r
283 )\r
284{\r
285 EFI_GUID **ProtocolGuidArray;\r
286 UINTN ArrayCount;\r
287 UINTN ProtocolIndex;\r
288 EFI_STATUS Status;\r
289 CHAR16 *RetVal;\r
290 UINTN Size;\r
291 CHAR16 *Temp;\r
292 CHAR16 GuidStr[40];\r
293 VOID *Instance;\r
294 CHAR16 InstanceStr[17];\r
295\r
296 ProtocolGuidArray = NULL;\r
297 RetVal = NULL;\r
298 Size = 0;\r
299\r
300 Status = gBS->ProtocolsPerHandle (\r
301 TheHandle,\r
302 &ProtocolGuidArray,\r
303 &ArrayCount\r
304 );\r
305 if (!EFI_ERROR (Status)) {\r
306 for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++) {\r
307 Temp = GetStringNameFromGuid (ProtocolGuidArray[ProtocolIndex], Language);\r
308 ASSERT ((RetVal == NULL && Size == 0) || (RetVal != NULL));\r
309 if (Size != 0) {\r
310 StrnCatGrow (&RetVal, &Size, Separator, 0);\r
311 }\r
312\r
313 StrnCatGrow (&RetVal, &Size, L"%H", 0);\r
314 if (Temp == NULL) {\r
315 UnicodeSPrint (GuidStr, sizeof (GuidStr), L"%g", ProtocolGuidArray[ProtocolIndex]);\r
316 StrnCatGrow (&RetVal, &Size, GuidStr, 0);\r
317 } else {\r
318 StrnCatGrow (&RetVal, &Size, Temp, 0);\r
319 FreePool (Temp);\r
320 }\r
321\r
322 StrnCatGrow (&RetVal, &Size, L"%N", 0);\r
323\r
324 if (Verbose) {\r
325 Status = gBS->HandleProtocol (TheHandle, ProtocolGuidArray[ProtocolIndex], &Instance);\r
326 if (!EFI_ERROR (Status)) {\r
327 StrnCatGrow (&RetVal, &Size, L"(%H", 0);\r
328 UnicodeSPrint (InstanceStr, sizeof (InstanceStr), L"%x", Instance);\r
329 StrnCatGrow (&RetVal, &Size, InstanceStr, 0);\r
330 StrnCatGrow (&RetVal, &Size, L"%N)", 0);\r
331 }\r
332 }\r
333\r
334 if (ExtraInfo) {\r
335 Temp = GetProtocolInformationDump (TheHandle, ProtocolGuidArray[ProtocolIndex], Verbose);\r
336 if (Temp != NULL) {\r
337 ASSERT ((RetVal == NULL && Size == 0) || (RetVal != NULL));\r
338 if (!Verbose) {\r
339 StrnCatGrow (&RetVal, &Size, L"(", 0);\r
340 StrnCatGrow (&RetVal, &Size, Temp, 0);\r
341 StrnCatGrow (&RetVal, &Size, L")", 0);\r
342 } else {\r
343 StrnCatGrow (&RetVal, &Size, Separator, 0);\r
344 StrnCatGrow (&RetVal, &Size, Temp, 0);\r
345 }\r
346\r
347 FreePool (Temp);\r
348 }\r
349 }\r
350 }\r
351 }\r
352\r
353 SHELL_FREE_NON_NULL (ProtocolGuidArray);\r
354\r
355 if (RetVal == NULL) {\r
356 return (NULL);\r
357 }\r
358\r
359 ASSERT ((RetVal == NULL && Size == 0) || (RetVal != NULL));\r
360 StrnCatGrow (&RetVal, &Size, Separator, 0);\r
361 return (RetVal);\r
362}\r
363\r
364/**\r
365 Gets the name of the loaded image.\r
366\r
367 @param[in] TheHandle The handle of the driver to get info on.\r
368 @param[out] Name The pointer to the pointer. Valid upon a successful return.\r
369\r
370 @retval EFI_SUCCESS The operation was successful.\r
371**/\r
372EFI_STATUS\r
373GetDriverImageName (\r
374 IN EFI_HANDLE TheHandle,\r
375 OUT CHAR16 **Name\r
376 )\r
377{\r
378 // get loaded image and devicepathtotext on image->Filepath\r
379 EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;\r
380 EFI_STATUS Status;\r
381 EFI_DEVICE_PATH_PROTOCOL *DevicePath;\r
382\r
383 if ((TheHandle == NULL) || (Name == NULL)) {\r
384 return (EFI_INVALID_PARAMETER);\r
385 }\r
386\r
387 Status = gBS->OpenProtocol (\r
388 TheHandle,\r
389 &gEfiLoadedImageProtocolGuid,\r
390 (VOID **)&LoadedImage,\r
391 gImageHandle,\r
392 NULL,\r
393 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
394 );\r
395 if (EFI_ERROR (Status)) {\r
396 return (Status);\r
397 }\r
398\r
399 DevicePath = LoadedImage->FilePath;\r
400 *Name = ConvertDevicePathToText (DevicePath, TRUE, TRUE);\r
401 return (EFI_SUCCESS);\r
402}\r
403\r
404/**\r
405 Display driver model information for a given handle.\r
406\r
407 @param[in] Handle The handle to display info on.\r
408 @param[in] BestName Use the best name?\r
409 @param[in] Language The language to output in.\r
410**/\r
411EFI_STATUS\r
412DisplayDriverModelHandle (\r
413 IN EFI_HANDLE Handle,\r
414 IN BOOLEAN BestName,\r
415 IN CONST CHAR8 *Language OPTIONAL\r
416 )\r
417{\r
418 EFI_STATUS Status;\r
419 BOOLEAN ConfigurationStatus;\r
420 BOOLEAN DiagnosticsStatus;\r
421 UINTN DriverBindingHandleCount;\r
422 EFI_HANDLE *DriverBindingHandleBuffer;\r
423 UINTN ParentControllerHandleCount;\r
424 EFI_HANDLE *ParentControllerHandleBuffer;\r
425 UINTN ChildControllerHandleCount;\r
426 EFI_HANDLE *ChildControllerHandleBuffer;\r
427 CHAR16 *TempStringPointer;\r
428 EFI_DEVICE_PATH_PROTOCOL *DevicePath;\r
429 UINTN Index;\r
430 CHAR16 *DriverName;\r
431 EFI_DRIVER_BINDING_PROTOCOL *DriverBinding;\r
432 UINTN NumberOfChildren;\r
433 UINTN HandleIndex;\r
434 UINTN ControllerHandleCount;\r
435 EFI_HANDLE *ControllerHandleBuffer;\r
436 UINTN ChildIndex;\r
437 BOOLEAN Image;\r
438\r
439 DriverName = NULL;\r
440\r
441 //\r
442 // See if Handle is a device handle and display its details.\r
443 //\r
444 DriverBindingHandleBuffer = NULL;\r
445 Status = PARSE_HANDLE_DATABASE_UEFI_DRIVERS (\r
446 Handle,\r
447 &DriverBindingHandleCount,\r
448 &DriverBindingHandleBuffer\r
449 );\r
450\r
451 ParentControllerHandleBuffer = NULL;\r
452 Status = PARSE_HANDLE_DATABASE_PARENTS (\r
453 Handle,\r
454 &ParentControllerHandleCount,\r
455 &ParentControllerHandleBuffer\r
456 );\r
457\r
458 ChildControllerHandleBuffer = NULL;\r
459 Status = ParseHandleDatabaseForChildControllers (\r
460 Handle,\r
461 &ChildControllerHandleCount,\r
462 &ChildControllerHandleBuffer\r
463 );\r
464\r
465 DiagnosticsStatus = FALSE;\r
466 ConfigurationStatus = FALSE;\r
467\r
468 if (!EFI_ERROR (gBS->OpenProtocol (Handle, &gEfiDriverConfigurationProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {\r
469 ConfigurationStatus = TRUE;\r
470 }\r
471\r
472 if (!EFI_ERROR (gBS->OpenProtocol (Handle, &gEfiDriverConfiguration2ProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {\r
473 ConfigurationStatus = TRUE;\r
474 }\r
475\r
476 if (!EFI_ERROR (gBS->OpenProtocol (Handle, &gEfiDriverDiagnosticsProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {\r
477 DiagnosticsStatus = TRUE;\r
478 }\r
479\r
480 if (!EFI_ERROR (gBS->OpenProtocol (Handle, &gEfiDriverDiagnostics2ProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {\r
481 DiagnosticsStatus = TRUE;\r
482 }\r
483\r
484 Status = EFI_SUCCESS;\r
485\r
486 if ((DriverBindingHandleCount > 0) || (ParentControllerHandleCount > 0) || (ChildControllerHandleCount > 0)) {\r
487 DevicePath = NULL;\r
488 TempStringPointer = NULL;\r
489 Status = gBS->HandleProtocol (Handle, &gEfiDevicePathProtocolGuid, (VOID **)&DevicePath);\r
490\r
491 Status = gEfiShellProtocol->GetDeviceName (Handle, EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8 *)Language, &TempStringPointer);\r
492 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_DRIVER1), gShellDriver1HiiHandle, TempStringPointer != NULL ? TempStringPointer : L"<Unknown>");\r
493 SHELL_FREE_NON_NULL (TempStringPointer);\r
494\r
495 TempStringPointer = ConvertDevicePathToText (DevicePath, TRUE, FALSE);\r
496 ShellPrintHiiEx (\r
497 -1,\r
498 -1,\r
499 NULL,\r
500 STRING_TOKEN (STR_DH_OUTPUT_DRIVER2),\r
501 gShellDriver1HiiHandle,\r
502 TempStringPointer != NULL ? TempStringPointer : L"<None>",\r
503 ParentControllerHandleCount == 0 ? L"ROOT" : (ChildControllerHandleCount > 0) ? L"BUS" : L"DEVICE",\r
504 ConfigurationStatus ? L"YES" : L"NO",\r
505 DiagnosticsStatus ? L"YES" : L"NO"\r
506 );\r
507\r
508 SHELL_FREE_NON_NULL (TempStringPointer);\r
509\r
510 if (DriverBindingHandleCount == 0) {\r
511 ShellPrintHiiEx (\r
512 -1,\r
513 -1,\r
514 NULL,\r
515 STRING_TOKEN (STR_DH_OUTPUT_DRIVER3),\r
516 gShellDriver1HiiHandle,\r
517 L"<None>"\r
518 );\r
519 } else {\r
520 ShellPrintHiiEx (\r
521 -1,\r
522 -1,\r
523 NULL,\r
524 STRING_TOKEN (STR_DH_OUTPUT_DRIVER3),\r
525 gShellDriver1HiiHandle,\r
526 L""\r
527 );\r
528 for (Index = 0; Index < DriverBindingHandleCount; Index++) {\r
529 Image = FALSE;\r
530 Status = GetDriverName (\r
531 DriverBindingHandleBuffer[Index],\r
532 Language,\r
533 &DriverName\r
534 );\r
535 if (EFI_ERROR (Status)) {\r
536 Status = GetDriverImageName (\r
537 DriverBindingHandleBuffer[Index],\r
538 &DriverName\r
539 );\r
540 if (EFI_ERROR (Status)) {\r
541 DriverName = NULL;\r
542 }\r
543 }\r
544\r
545 if (Image) {\r
546 ShellPrintHiiEx (\r
547 -1,\r
548 -1,\r
549 NULL,\r
550 STRING_TOKEN (STR_DH_OUTPUT_DRIVER4A),\r
551 gShellDriver1HiiHandle,\r
552 ConvertHandleToHandleIndex (DriverBindingHandleBuffer[Index]),\r
553 DriverName != NULL ? DriverName : L"<Unknown>"\r
554 );\r
555 } else {\r
556 ShellPrintHiiEx (\r
557 -1,\r
558 -1,\r
559 NULL,\r
560 STRING_TOKEN (STR_DH_OUTPUT_DRIVER4B),\r
561 gShellDriver1HiiHandle,\r
562 ConvertHandleToHandleIndex (DriverBindingHandleBuffer[Index]),\r
563 DriverName != NULL ? DriverName : L"<Unknown>"\r
564 );\r
565 }\r
566\r
567 SHELL_FREE_NON_NULL (DriverName);\r
568 }\r
569 }\r
570\r
571 if (ParentControllerHandleCount == 0) {\r
572 ShellPrintHiiEx (\r
573 -1,\r
574 -1,\r
575 NULL,\r
576 STRING_TOKEN (STR_DH_OUTPUT_DRIVER5),\r
577 gShellDriver1HiiHandle,\r
578 L"<None>"\r
579 );\r
580 } else {\r
581 ShellPrintHiiEx (\r
582 -1,\r
583 -1,\r
584 NULL,\r
585 STRING_TOKEN (STR_DH_OUTPUT_DRIVER5),\r
586 gShellDriver1HiiHandle,\r
587 L""\r
588 );\r
589 for (Index = 0; Index < ParentControllerHandleCount; Index++) {\r
590 Status = gEfiShellProtocol->GetDeviceName (ParentControllerHandleBuffer[Index], EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8 *)Language, &TempStringPointer);\r
591 ShellPrintHiiEx (\r
592 -1,\r
593 -1,\r
594 NULL,\r
595 STRING_TOKEN (STR_DH_OUTPUT_DRIVER5B),\r
596 gShellDriver1HiiHandle,\r
597 ConvertHandleToHandleIndex (ParentControllerHandleBuffer[Index]),\r
598 TempStringPointer != NULL ? TempStringPointer : L"<Unknown>"\r
599 );\r
600 SHELL_FREE_NON_NULL (TempStringPointer);\r
601 }\r
602 }\r
603\r
604 if (ChildControllerHandleCount == 0) {\r
605 ShellPrintHiiEx (\r
606 -1,\r
607 -1,\r
608 NULL,\r
609 STRING_TOKEN (STR_DH_OUTPUT_DRIVER6),\r
610 gShellDriver1HiiHandle,\r
611 L"<None>"\r
612 );\r
613 } else {\r
614 ShellPrintHiiEx (\r
615 -1,\r
616 -1,\r
617 NULL,\r
618 STRING_TOKEN (STR_DH_OUTPUT_DRIVER6),\r
619 gShellDriver1HiiHandle,\r
620 L""\r
621 );\r
622 for (Index = 0; Index < ChildControllerHandleCount; Index++) {\r
623 Status = gEfiShellProtocol->GetDeviceName (ChildControllerHandleBuffer[Index], EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8 *)Language, &TempStringPointer);\r
624 ShellPrintHiiEx (\r
625 -1,\r
626 -1,\r
627 NULL,\r
628 STRING_TOKEN (STR_DH_OUTPUT_DRIVER6B),\r
629 gShellDriver1HiiHandle,\r
630 ConvertHandleToHandleIndex (ChildControllerHandleBuffer[Index]),\r
631 TempStringPointer != NULL ? TempStringPointer : L"<Unknown>"\r
632 );\r
633 SHELL_FREE_NON_NULL (TempStringPointer);\r
634 }\r
635 }\r
636 }\r
637\r
638 SHELL_FREE_NON_NULL (DriverBindingHandleBuffer);\r
639\r
640 SHELL_FREE_NON_NULL (ParentControllerHandleBuffer);\r
641\r
642 SHELL_FREE_NON_NULL (ChildControllerHandleBuffer);\r
643\r
644 if (EFI_ERROR (Status)) {\r
645 return Status;\r
646 }\r
647\r
648 //\r
649 // See if Handle is a driver binding handle and display its details.\r
650 //\r
651 Status = gBS->OpenProtocol (\r
652 Handle,\r
653 &gEfiDriverBindingProtocolGuid,\r
654 (VOID **)&DriverBinding,\r
655 NULL,\r
656 NULL,\r
657 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
658 );\r
659 if (EFI_ERROR (Status)) {\r
660 return EFI_SUCCESS;\r
661 }\r
662\r
663 NumberOfChildren = 0;\r
664 ControllerHandleBuffer = NULL;\r
665 Status = PARSE_HANDLE_DATABASE_DEVICES (\r
666 Handle,\r
667 &ControllerHandleCount,\r
668 &ControllerHandleBuffer\r
669 );\r
670 if (ControllerHandleCount > 0) {\r
671 for (HandleIndex = 0; HandleIndex < ControllerHandleCount; HandleIndex++) {\r
672 Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (\r
673 Handle,\r
674 ControllerHandleBuffer[HandleIndex],\r
675 &ChildControllerHandleCount,\r
676 NULL\r
677 );\r
678 NumberOfChildren += ChildControllerHandleCount;\r
679 }\r
680 }\r
681\r
682 Status = GetDriverName (Handle, Language, &DriverName);\r
683 if (EFI_ERROR (Status)) {\r
684 DriverName = NULL;\r
685 }\r
686\r
687 ShellPrintHiiEx (\r
688 -1,\r
689 -1,\r
690 NULL,\r
691 STRING_TOKEN (STR_DH_OUTPUT_DRIVER7),\r
692 gShellDriver1HiiHandle,\r
693 ConvertHandleToHandleIndex (Handle),\r
694 DriverName != NULL ? DriverName : L"<Unknown>"\r
695 );\r
696 SHELL_FREE_NON_NULL (DriverName);\r
697 Status = GetDriverImageName (\r
698 Handle,\r
699 &DriverName\r
700 );\r
701 if (EFI_ERROR (Status)) {\r
702 DriverName = NULL;\r
703 }\r
704\r
705 ShellPrintHiiEx (\r
706 -1,\r
707 -1,\r
708 NULL,\r
709 STRING_TOKEN (STR_DH_OUTPUT_DRIVER7B),\r
710 gShellDriver1HiiHandle,\r
711 DriverName != NULL ? DriverName : L"<Unknown>"\r
712 );\r
713 SHELL_FREE_NON_NULL (DriverName);\r
714\r
715 ShellPrintHiiEx (\r
716 -1,\r
717 -1,\r
718 NULL,\r
719 STRING_TOKEN (STR_DH_OUTPUT_DRIVER8),\r
720 gShellDriver1HiiHandle,\r
721 DriverBinding->Version,\r
722 NumberOfChildren > 0 ? L"Bus" : ControllerHandleCount > 0 ? L"Device" : L"<Unknown>",\r
723 ConfigurationStatus ? L"YES" : L"NO",\r
724 DiagnosticsStatus ? L"YES" : L"NO"\r
725 );\r
726\r
727 if (ControllerHandleCount == 0) {\r
728 ShellPrintHiiEx (\r
729 -1,\r
730 -1,\r
731 NULL,\r
732 STRING_TOKEN (STR_DH_OUTPUT_DRIVER9),\r
733 gShellDriver1HiiHandle,\r
734 L"None"\r
735 );\r
736 } else {\r
737 ShellPrintHiiEx (\r
738 -1,\r
739 -1,\r
740 NULL,\r
741 STRING_TOKEN (STR_DH_OUTPUT_DRIVER9),\r
742 gShellDriver1HiiHandle,\r
743 L""\r
744 );\r
745 for (HandleIndex = 0; HandleIndex < ControllerHandleCount; HandleIndex++) {\r
746 Status = gEfiShellProtocol->GetDeviceName (ControllerHandleBuffer[HandleIndex], EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8 *)Language, &TempStringPointer);\r
747\r
748 ShellPrintHiiEx (\r
749 -1,\r
750 -1,\r
751 NULL,\r
752 STRING_TOKEN (STR_DH_OUTPUT_DRIVER9B),\r
753 gShellDriver1HiiHandle,\r
754 ConvertHandleToHandleIndex (ControllerHandleBuffer[HandleIndex]),\r
755 TempStringPointer != NULL ? TempStringPointer : L"<Unknown>"\r
756 );\r
757 SHELL_FREE_NON_NULL (TempStringPointer);\r
758\r
759 Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (\r
760 Handle,\r
761 ControllerHandleBuffer[HandleIndex],\r
762 &ChildControllerHandleCount,\r
763 &ChildControllerHandleBuffer\r
764 );\r
765 if (!EFI_ERROR (Status)) {\r
766 for (ChildIndex = 0; ChildIndex < ChildControllerHandleCount; ChildIndex++) {\r
767 Status = gEfiShellProtocol->GetDeviceName (ChildControllerHandleBuffer[ChildIndex], EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8 *)Language, &TempStringPointer);\r
768\r
769 ShellPrintHiiEx (\r
770 -1,\r
771 -1,\r
772 NULL,\r
773 STRING_TOKEN (STR_DH_OUTPUT_DRIVER6C),\r
774 gShellDriver1HiiHandle,\r
775 ConvertHandleToHandleIndex (ChildControllerHandleBuffer[ChildIndex]),\r
776 TempStringPointer != NULL ? TempStringPointer : L"<Unknown>"\r
777 );\r
778 SHELL_FREE_NON_NULL (TempStringPointer);\r
779 }\r
780\r
781 SHELL_FREE_NON_NULL (ChildControllerHandleBuffer);\r
782 }\r
783 }\r
784\r
785 SHELL_FREE_NON_NULL (ControllerHandleBuffer);\r
786 }\r
787\r
788 return EFI_SUCCESS;\r
789}\r
790\r
791/**\r
792 Display information for a handle.\r
793\r
794 @param[in] TheHandle The handles to show info on.\r
795 @param[in] Verbose TRUE for extra info, FALSE otherwise.\r
796 @param[in] Sfo TRUE to output in standard format output (spec).\r
797 @param[in] Language Language string per UEFI specification.\r
798 @param[in] DriverInfo TRUE to show all info about the handle.\r
799 @param[in] Multiple TRUE indicates more than will be output,\r
800 FALSE for a single one.\r
801**/\r
802VOID\r
803DoDhByHandle (\r
804 IN CONST EFI_HANDLE TheHandle,\r
805 IN CONST BOOLEAN Verbose,\r
806 IN CONST BOOLEAN Sfo,\r
807 IN CONST CHAR8 *Language,\r
808 IN CONST BOOLEAN DriverInfo,\r
809 IN CONST BOOLEAN Multiple\r
810 )\r
811{\r
812 CHAR16 *ProtocolInfoString;\r
813\r
814 ProtocolInfoString = NULL;\r
815\r
816 if (!Sfo) {\r
817 if (Multiple) {\r
818 ProtocolInfoString = GetProtocolInfoString (TheHandle, Language, L" ", Verbose, TRUE);\r
819 ShellPrintHiiEx (\r
820 -1,\r
821 -1,\r
822 NULL,\r
823 STRING_TOKEN (STR_DH_OUTPUT),\r
824 gShellDriver1HiiHandle,\r
825 ConvertHandleToHandleIndex (TheHandle),\r
826 ProtocolInfoString == NULL ? L"" : ProtocolInfoString\r
827 );\r
828 } else {\r
829 ProtocolInfoString = GetProtocolInfoString (TheHandle, Language, Verbose ? L"\r\n" : L" ", Verbose, TRUE);\r
830 if (Verbose) {\r
831 ShellPrintHiiEx (\r
832 -1,\r
833 -1,\r
834 NULL,\r
835 STRING_TOKEN (STR_DH_OUTPUT_SINGLE),\r
836 gShellDriver1HiiHandle,\r
837 ConvertHandleToHandleIndex (TheHandle),\r
838 TheHandle,\r
839 ProtocolInfoString == NULL ? L"" : ProtocolInfoString\r
840 );\r
841 } else {\r
842 ShellPrintHiiEx (\r
843 -1,\r
844 -1,\r
845 NULL,\r
846 STRING_TOKEN (STR_DH_OUTPUT_SINGLE_D),\r
847 gShellDriver1HiiHandle,\r
848 ConvertHandleToHandleIndex (TheHandle),\r
849 ProtocolInfoString == NULL ? L"" : ProtocolInfoString\r
850 );\r
851 }\r
852 }\r
853\r
854 if (DriverInfo) {\r
855 DisplayDriverModelHandle ((EFI_HANDLE)TheHandle, TRUE, Language);\r
856 }\r
857 } else {\r
858 ProtocolInfoString = GetProtocolInfoString (TheHandle, Language, L";", FALSE, FALSE);\r
859 ShellPrintHiiEx (\r
860 -1,\r
861 -1,\r
862 NULL,\r
863 STRING_TOKEN (STR_DH_OUTPUT_SFO),\r
864 gShellDriver1HiiHandle,\r
865 Multiple ? L"HandlesInfo" : L"HandleInfo",\r
866 L"DriverName",\r
867 L"ControllerName",\r
868 ConvertHandleToHandleIndex (TheHandle),\r
869 L"DevPath",\r
870 ProtocolInfoString == NULL ? L"" : ProtocolInfoString\r
871 );\r
872 }\r
873\r
874 if (ProtocolInfoString != NULL) {\r
875 FreePool (ProtocolInfoString);\r
876 }\r
877}\r
878\r
879/**\r
880 Display information for all handles on a list.\r
881\r
882 @param[in] HandleList The NULL-terminated list of handles.\r
883 @param[in] Verbose TRUE for extra info, FALSE otherwise.\r
884 @param[in] Sfo TRUE to output in standard format output (spec).\r
885 @param[in] Language Language string per UEFI specification.\r
886 @param[in] DriverInfo TRUE to show all info about the handle.\r
887\r
888 @retval SHELL_SUCCESS The operation was successful.\r
889 @retval SHELL_ABORTED The operation was aborted.\r
890**/\r
891SHELL_STATUS\r
892DoDhForHandleList (\r
893 IN CONST EFI_HANDLE *HandleList,\r
894 IN CONST BOOLEAN Verbose,\r
895 IN CONST BOOLEAN Sfo,\r
896 IN CONST CHAR8 *Language,\r
897 IN CONST BOOLEAN DriverInfo\r
898 )\r
899{\r
900 CONST EFI_HANDLE *HandleWalker;\r
901 SHELL_STATUS ShellStatus;\r
902\r
903 ShellStatus = SHELL_SUCCESS;\r
904 for (HandleWalker = HandleList; HandleWalker != NULL && *HandleWalker != NULL; HandleWalker++) {\r
905 DoDhByHandle (*HandleWalker, Verbose, Sfo, Language, DriverInfo, TRUE);\r
906 if (ShellGetExecutionBreakFlag ()) {\r
907 ShellStatus = SHELL_ABORTED;\r
908 break;\r
909 }\r
910 }\r
911\r
912 return (ShellStatus);\r
913}\r
914\r
915/**\r
916 Display information for a GUID of protocol.\r
917\r
918 @param[in] Guid The pointer to the name of the protocol.\r
919 @param[in] Verbose TRUE for extra info, FALSE otherwise.\r
920 @param[in] Sfo TRUE to output in standard format output (spec).\r
921 @param[in] Language Language string per UEFI specification.\r
922 @param[in] DriverInfo TRUE to show all info about the handle.\r
923\r
924 @retval SHELL_SUCCESS The operation was successful.\r
925 @retval SHELL_NOT_FOUND The GUID was not found.\r
926 @retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.\r
927**/\r
928SHELL_STATUS\r
929DoDhByProtocolGuid (\r
930 IN CONST GUID *Guid,\r
931 IN CONST BOOLEAN Verbose,\r
932 IN CONST BOOLEAN Sfo,\r
933 IN CONST CHAR8 *Language,\r
934 IN CONST BOOLEAN DriverInfo\r
935 )\r
936{\r
937 CHAR16 *Name;\r
938 SHELL_STATUS ShellStatus;\r
939 EFI_HANDLE *HandleList;\r
940\r
941 if (!Sfo) {\r
942 if (Guid == NULL) {\r
943 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_ALL_HEADER), gShellDriver1HiiHandle);\r
944 } else {\r
945 Name = GetStringNameFromGuid (Guid, NULL);\r
946 if (Name == NULL) {\r
947 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_GUID_HEADER), gShellDriver1HiiHandle, Guid);\r
948 } else {\r
949 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_NAME_HEADER), gShellDriver1HiiHandle, Name);\r
950 }\r
951 }\r
952 }\r
953\r
954 HandleList = GetHandleListByProtocol (Guid);\r
955 ShellStatus = DoDhForHandleList (HandleList, Verbose, Sfo, Language, DriverInfo);\r
956 SHELL_FREE_NON_NULL (HandleList);\r
957\r
958 return ShellStatus;\r
959}\r
960\r
961/**\r
962 Function to determine use which method to print information.\r
963 If Protocol is NULL, The function will print all information.\r
964\r
965 @param[in] Protocol The pointer to the name or GUID of protocol or NULL.\r
966 @param[in] Verbose TRUE for extra info, FALSE otherwise.\r
967 @param[in] Sfo TRUE to output in standard format output (spec).\r
968 @param[in] Language Language string per UEFI specification.\r
969 @param[in] DriverInfo TRUE to show all info about the handle.\r
970\r
971 @retval SHELL_SUCCESS The operation was successful.\r
972 @retval SHELL_NOT_FOUND The protocol was not found.\r
973 @retval SHELL_INVALID_PARAMETER Protocol is invalid parameter.\r
974**/\r
975SHELL_STATUS\r
976DoDhByProtocol (\r
977 IN CONST CHAR16 *Protocol,\r
978 IN CONST BOOLEAN Verbose,\r
979 IN CONST BOOLEAN Sfo,\r
980 IN CONST CHAR8 *Language,\r
981 IN CONST BOOLEAN DriverInfo\r
982 )\r
983{\r
984 EFI_GUID Guid;\r
985 EFI_GUID *GuidPtr;\r
986 EFI_STATUS Status;\r
987\r
988 if (Protocol == NULL) {\r
989 return DoDhByProtocolGuid (NULL, Verbose, Sfo, Language, DriverInfo);\r
990 } else {\r
991 Status = ConvertStrToGuid (Protocol, &Guid);\r
992 if (!EFI_ERROR (Status)) {\r
993 GuidPtr = &Guid;\r
994 } else {\r
995 //\r
996 // Protocol is a Name, convert it to GUID\r
997 //\r
998 Status = GetGuidFromStringName (Protocol, Language, &GuidPtr);\r
999 if (EFI_ERROR (Status)) {\r
1000 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_NO_NAME_FOUND), gShellDriver1HiiHandle, Protocol);\r
1001 return (SHELL_NOT_FOUND);\r
1002 }\r
1003 }\r
1004\r
1005 return DoDhByProtocolGuid (GuidPtr, Verbose, Sfo, Language, DriverInfo);\r
1006 }\r
1007}\r
1008\r
1009/**\r
1010 Function to display decode information by Protocol.\r
1011 The parameter Protocol is either a GUID or the name of protocol.\r
1012 If the parameter Protocol is NULL, the function will print all\r
1013 decode information.\r
1014\r
1015 @param[in] Protocol The pointer to the name or GUID of protocol.\r
1016 @param[in] Language Language string per UEFI specification.\r
1017\r
1018 @retval SHELL_SUCCESS The operation was successful.\r
1019 @retval SHELL_OUT_OT_RESOURCES A memory allocation failed.\r
1020**/\r
1021SHELL_STATUS\r
1022DoDecodeByProtocol (\r
1023 IN CONST CHAR16 *Protocol,\r
1024 IN CONST CHAR8 *Language\r
1025 )\r
1026{\r
1027 EFI_STATUS Status;\r
1028 EFI_GUID *Guids;\r
1029 EFI_GUID Guid;\r
1030 UINTN Counts;\r
1031 UINTN Index;\r
1032 CHAR16 *Name;\r
1033\r
1034 if (Protocol == NULL) {\r
1035 Counts = 0;\r
1036 Status = GetAllMappingGuids (NULL, &Counts);\r
1037 if (Status == EFI_BUFFER_TOO_SMALL) {\r
1038 Guids = AllocatePool (Counts * sizeof (EFI_GUID));\r
1039 if (Guids == NULL) {\r
1040 return SHELL_OUT_OF_RESOURCES;\r
1041 }\r
1042\r
1043 Status = GetAllMappingGuids (Guids, &Counts);\r
1044 if (Status == EFI_SUCCESS) {\r
1045 for (Index = 0; Index < Counts; Index++) {\r
1046 Name = GetStringNameFromGuid (&Guids[Index], Language);\r
1047 if (Name != NULL) {\r
1048 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_DECODE), gShellDriver1HiiHandle, Name, &Guids[Index]);\r
1049 } else {\r
1050 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_NO_GUID_FOUND), gShellDriver1HiiHandle, &Guids[Index]);\r
1051 }\r
1052\r
1053 SHELL_FREE_NON_NULL (Name);\r
1054 }\r
1055 }\r
1056\r
1057 FreePool (Guids);\r
1058 }\r
1059 } else {\r
1060 if (ConvertStrToGuid (Protocol, &Guid) == EFI_SUCCESS) {\r
1061 Name = GetStringNameFromGuid (&Guid, Language);\r
1062 if (Name != NULL) {\r
1063 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_DECODE), gShellDriver1HiiHandle, Name, &Guid);\r
1064 } else {\r
1065 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_NO_GUID_FOUND), gShellDriver1HiiHandle, &Guid);\r
1066 }\r
1067\r
1068 SHELL_FREE_NON_NULL (Name);\r
1069 } else {\r
1070 Status = GetGuidFromStringName (Protocol, Language, &Guids);\r
1071 if (Status == EFI_SUCCESS) {\r
1072 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_DECODE), gShellDriver1HiiHandle, Protocol, Guids);\r
1073 } else {\r
1074 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_NO_NAME_FOUND), gShellDriver1HiiHandle, Protocol);\r
1075 }\r
1076 }\r
1077 }\r
1078\r
1079 return SHELL_SUCCESS;\r
1080}\r
1081\r
1082/**\r
1083 Function for 'dh' command.\r
1084\r
1085 @param[in] ImageHandle Handle to the Image (NULL if Internal).\r
1086 @param[in] SystemTable Pointer to the System Table (NULL if Internal).\r
1087**/\r
1088SHELL_STATUS\r
1089EFIAPI\r
1090ShellCommandRunDh (\r
1091 IN EFI_HANDLE ImageHandle,\r
1092 IN EFI_SYSTEM_TABLE *SystemTable\r
1093 )\r
1094{\r
1095 EFI_STATUS Status;\r
1096 LIST_ENTRY *Package;\r
1097 CHAR16 *ProblemParam;\r
1098 SHELL_STATUS ShellStatus;\r
1099 CHAR8 *Language;\r
1100 CONST CHAR16 *Lang;\r
1101 CONST CHAR16 *RawValue;\r
1102 CONST CHAR16 *ProtocolVal;\r
1103 BOOLEAN SfoFlag;\r
1104 BOOLEAN DriverFlag;\r
1105 BOOLEAN VerboseFlag;\r
1106 UINT64 Intermediate;\r
1107 EFI_HANDLE Handle;\r
1108\r
1109 ShellStatus = SHELL_SUCCESS;\r
1110 Status = EFI_SUCCESS;\r
1111 Language = NULL;\r
1112\r
1113 //\r
1114 // initialize the shell lib (we must be in non-auto-init...)\r
1115 //\r
1116 Status = ShellInitialize ();\r
1117 ASSERT_EFI_ERROR (Status);\r
1118\r
1119 Status = CommandInit ();\r
1120 ASSERT_EFI_ERROR (Status);\r
1121\r
1122 //\r
1123 // parse the command line\r
1124 //\r
1125 Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);\r
1126 if (EFI_ERROR (Status)) {\r
1127 if ((Status == EFI_VOLUME_CORRUPTED) && (ProblemParam != NULL)) {\r
1128 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDriver1HiiHandle, L"dh", ProblemParam);\r
1129 FreePool (ProblemParam);\r
1130 ShellStatus = SHELL_INVALID_PARAMETER;\r
1131 } else {\r
1132 ASSERT (FALSE);\r
1133 }\r
1134 } else {\r
1135 if (ShellCommandLineGetCount (Package) > 2) {\r
1136 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle, L"dh");\r
1137 ShellCommandLineFreeVarList (Package);\r
1138 return (SHELL_INVALID_PARAMETER);\r
1139 }\r
1140\r
1141 if (ShellCommandLineGetFlag (Package, L"-l")) {\r
1142 Lang = ShellCommandLineGetValue (Package, L"-l");\r
1143 if (Lang != NULL) {\r
1144 Language = AllocateZeroPool (StrSize (Lang));\r
1145 AsciiSPrint (Language, StrSize (Lang), "%S", Lang);\r
1146 } else {\r
1147 ASSERT (Language == NULL);\r
1148 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"dh", L"-l");\r
1149 ShellCommandLineFreeVarList (Package);\r
1150 return (SHELL_INVALID_PARAMETER);\r
1151 }\r
1152 } else {\r
1153 Language = AllocateZeroPool (10);\r
1154 AsciiSPrint (Language, 10, "en-us");\r
1155 }\r
1156\r
1157 SfoFlag = ShellCommandLineGetFlag (Package, L"-sfo");\r
1158 DriverFlag = ShellCommandLineGetFlag (Package, L"-d");\r
1159 VerboseFlag = (BOOLEAN)(ShellCommandLineGetFlag (Package, L"-v") || ShellCommandLineGetFlag (Package, L"-verbose"));\r
1160 RawValue = ShellCommandLineGetRawValue (Package, 1);\r
1161 ProtocolVal = ShellCommandLineGetValue (Package, L"-p");\r
1162\r
1163 if (RawValue == NULL) {\r
1164 if (ShellCommandLineGetFlag (Package, L"-p") && (ProtocolVal == NULL)) {\r
1165 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"dh", L"-p");\r
1166 ShellStatus = SHELL_INVALID_PARAMETER;\r
1167 } else {\r
1168 //\r
1169 // Print information by protocol, The ProtocolVal maybe is name or GUID or NULL.\r
1170 //\r
1171 ShellStatus = DoDhByProtocol (ProtocolVal, VerboseFlag, SfoFlag, Language, DriverFlag);\r
1172 }\r
1173 } else if ((RawValue != NULL) &&\r
1174 (gUnicodeCollation->StriColl (gUnicodeCollation, L"decode", (CHAR16 *)RawValue) == 0))\r
1175 {\r
1176 if (ShellCommandLineGetFlag (Package, L"-p") && (ProtocolVal == NULL)) {\r
1177 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"dh", L"-p");\r
1178 ShellStatus = SHELL_INVALID_PARAMETER;\r
1179 } else {\r
1180 //\r
1181 // Print decode informatino by protocol.\r
1182 //\r
1183 ShellStatus = DoDecodeByProtocol (ProtocolVal, Language);\r
1184 }\r
1185 } else {\r
1186 if (ShellCommandLineGetFlag (Package, L"-p")) {\r
1187 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle, L"dh");\r
1188 ShellStatus = SHELL_INVALID_PARAMETER;\r
1189 } else {\r
1190 Status = ShellConvertStringToUint64 (RawValue, &Intermediate, TRUE, FALSE);\r
1191 if (EFI_ERROR (Status)) {\r
1192 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, L"dh", RawValue);\r
1193 ShellStatus = SHELL_INVALID_PARAMETER;\r
1194 } else {\r
1195 Handle = ConvertHandleIndexToHandle ((UINTN)Intermediate);\r
1196 if (Handle == NULL) {\r
1197 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, L"dh", RawValue);\r
1198 ShellStatus = SHELL_INVALID_PARAMETER;\r
1199 } else {\r
1200 //\r
1201 // Print information by handle.\r
1202 //\r
1203 DoDhByHandle (Handle, VerboseFlag, SfoFlag, Language, DriverFlag, FALSE);\r
1204 }\r
1205 }\r
1206 }\r
1207 }\r
1208\r
1209 ShellCommandLineFreeVarList (Package);\r
1210 SHELL_FREE_NON_NULL (Language);\r
1211 }\r
1212\r
1213 return (ShellStatus);\r
1214}\r
EFI Development Kit II mirror for PVE