SHEL22
[efi/shell/.git] / shellenv / protid.c
1 /*++
2
3 Copyright (c) 2005 - 2009, Intel Corporation                                                         
4 All rights reserved. This program and the accompanying materials                          
5 are licensed and made available under the terms and conditions of the BSD License         
6 which accompanies this distribution. The full text of the license may be found at         
7 http://opensource.org/licenses/bsd-license.php                                            
8                                                                                           
9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
11
12 Module Name:
13
14   protid.c
15  
16 Abstract:
17
18   Shell environment protocol id information management
19
20
21
22 Revision History
23
24 --*/
25
26 #include "shelle.h"
27 #include "shellenvguid.h"
28
29 #if (PLATFORM == NT32)
30 #define LOCAL_EFI_WIN_NT_THUNK_PROTOCOL_GUID \
31   { \
32     0x58c518b1, 0x76f3, 0x11d4, 0xbc, 0xea, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 \
33   }
34
35 #define LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID \
36   { \
37     0x96eb4ad6, 0xa32a, 0x11d4, 0xbc, 0xfd, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 \
38   }
39
40 #define LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID \
41   { \
42     0xc95a93d, 0xa006, 0x11d4, 0xbc, 0xfa, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 \
43   }
44 #endif
45
46 struct {
47   CHAR16                      *IdString;
48   SHELLENV_DUMP_PROTOCOL_INFO DumpInfo;
49   SHELLENV_DUMP_PROTOCOL_INFO DumpToken;
50   EFI_GUID                    ProtocolId;
51 }
52 SEnvInternalProtocolInfo[] = {
53   //
54   // Loaded Image
55   //
56   L"Image",
57   SEnvImage,
58   SEnvImageTok,
59   EFI_LOADED_IMAGE_PROTOCOL_GUID,
60   //
61   // Device Path
62   //
63   L"Dpath",
64   SEnvDPath,
65   SEnvDPathTok,
66   EFI_DEVICE_PATH_PROTOCOL_GUID,
67   L"ImageDpath",
68   SEnvDPath,
69   SEnvImageDPathTok,
70   EFI_LOADED_IMAGE_DEVICE_PATH_PROTOCOL_GUID,
71   L"DpathUtil",
72   NULL,
73   NULL,
74   EFI_DEVICE_PATH_UTILITIES_PROTOCOL_GUID,
75   L"DpathToText",
76   NULL,
77   NULL,
78   EFI_DEVICE_PATH_TO_TEXT_PROTOCOL_GUID,
79   L"DpathFromText",
80   NULL,
81   NULL,
82   EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL_GUID,
83   L"PcAnsi",
84   NULL,
85   NULL,
86   DEVICE_PATH_MESSAGING_PC_ANSI,
87   L"Vt100",
88   NULL,
89   NULL,
90   DEVICE_PATH_MESSAGING_VT_100,
91   L"Vt100+",
92   NULL,
93   NULL,
94   DEVICE_PATH_MESSAGING_VT_100_PLUS,
95   L"VtUtf8",
96   NULL,
97   NULL,
98   DEVICE_PATH_MESSAGING_VT_UTF8,
99   //
100   // Driver Model
101   //
102   L"DriverBinding",
103   NULL,
104   NULL,
105   EFI_DRIVER_BINDING_PROTOCOL_GUID,
106   L"PlatformOverride",
107   NULL,
108   NULL,
109   EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL_GUID,
110   L"BusSpecificDriverOverride",
111   SEnvBusSpecificDriverOverride,
112   NULL,
113   EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL_GUID,
114   L"Diagnostics",
115   NULL,
116   NULL,
117   EFI_DRIVER_DIAGNOSTICS_PROTOCOL_GUID,
118   L"Diagnostics2",
119   NULL,
120   NULL,
121   EFI_DRIVER_DIAGNOSTICS2_PROTOCOL_GUID,
122   L"ComponentName",
123   NULL,
124   NULL,
125   EFI_COMPONENT_NAME_PROTOCOL_GUID,
126   L"ComponentName2",
127   NULL,
128   NULL,
129   EFI_COMPONENT_NAME2_PROTOCOL_GUID,
130   L"PlatformDriverConfig",
131   NULL,
132   NULL,
133   EFI_PLATFORM_TO_DRIVER_CONFIGURATION_PROTOCOL_GUID,
134   L"DriverEFIVersion",
135   SEnvDriverEFIVersion,
136   SEnvDriverEFIVersionTok,
137   EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL_GUID,
138   //
139   // Console Support
140   //
141   L"TxtinEx",
142   NULL,
143   NULL,
144   EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL_GUID,
145   L"Txtin",
146   NULL,
147   NULL,
148   EFI_SIMPLE_TEXT_IN_PROTOCOL_GUID,
149   L"Txtout",
150   SEnvTextOut,
151   NULL,
152   EFI_SIMPLE_TEXT_OUT_PROTOCOL_GUID,
153   L"SimplePointer",
154   NULL,
155   NULL,
156   EFI_SIMPLE_POINTER_PROTOCOL_GUID,
157   L"AbsolutePointer",
158   NULL,
159   NULL,
160   EFI_ABSOLUTE_POINTER_PROTOCOL_GUID,
161   L"SerialIo",
162   NULL,
163   NULL,
164   EFI_SERIAL_IO_PROTOCOL_GUID,
165   L"GraphicsOutput",
166   SEnvGraphicsOutput,
167   NULL,
168   EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID,
169   L"EdidDiscovered",
170   NULL,
171   NULL,
172   EFI_EDID_DISCOVERED_PROTOCOL_GUID,
173   L"EdidActive",
174   NULL,
175   NULL,
176   EFI_EDID_ACTIVE_PROTOCOL_GUID,
177   L"EdidOverride",
178   NULL,
179   NULL,
180   EFI_EDID_OVERRIDE_PROTOCOL_GUID,
181   L"ConIn",
182   NULL,
183   NULL,
184   EFI_CONSOLE_IN_DEVICE_GUID,
185   L"ConOut",
186   NULL,
187   NULL,
188   EFI_CONSOLE_OUT_DEVICE_GUID,
189   L"StdErr",
190   NULL,
191   NULL,
192   EFI_STANDARD_ERROR_DEVICE_GUID,
193   //
194   // Media Access
195   //
196   L"Load",
197   NULL,
198   NULL,
199   LOAD_FILE_PROTOCOL_GUID,
200   L"Load2",
201   NULL,
202   NULL,
203   EFI_LOAD_FILE2_PROTOCOL_GUID,
204   L"Fs",
205   NULL,
206   NULL,
207   EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID,
208   L"GenFileInfo",
209   NULL,
210   NULL,
211   EFI_FILE_INFO_ID,
212   L"TapeIo",
213   NULL,
214   NULL,
215   EFI_TAPE_IO_PROTOCOL_GUID,
216   L"DiskIo",
217   NULL,
218   NULL,
219   EFI_DISK_IO_PROTOCOL_GUID,
220   L"BlkIo",
221   SEnvBlkIo,
222   NULL,
223   EFI_BLOCK_IO_PROTOCOL_GUID,
224   L"UnicodeCollation",
225   NULL,
226   NULL,
227   EFI_UNICODE_COLLATION_PROTOCOL_GUID,
228   L"UnicodeCollation2",
229   NULL,
230   NULL,
231   EFI_UNICODE_COLLATION2_PROTOCOL_GUID,
232   //
233   // PCI Bus Support
234   //
235   L"PciRootBridgeIo",
236   SEnvPciRootBridgeIo,
237   NULL,
238   EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_GUID,
239   L"PciIo",
240   SEnvPciIo,
241   NULL,
242   EFI_PCI_IO_PROTOCOL_GUID,
243   //
244   // SCSI Bus Support
245   //
246   L"ScsiPassThru",
247   NULL,
248   NULL,
249   EFI_SCSI_PASS_THRU_PROTOCOL_GUID,
250   L"ScsiIo",
251   NULL,
252   NULL,
253   EFI_SCSI_IO_PROTOCOL_GUID,
254   L"ExtScsiPassThru",
255   NULL,
256   NULL,
257   EFI_EXT_SCSI_PASS_THRU_PROTOCOL_GUID,
258   //
259   // iSCSI
260   //
261   L"IScsiInitName",
262   NULL,
263   NULL,
264   EFI_ISCSI_INITIATOR_NAME_PROTOCOL_GUID,
265   //
266   // USB Support
267   //
268   L"UsbIo",
269   SEnvUsbIo,
270   NULL,
271   EFI_USB_IO_PROTOCOL_GUID,
272   L"UsbHc",
273   NULL,
274   NULL,
275   EFI_USB_HC_PROTOCOL_GUID,
276   L"UsbHc2",
277   NULL,
278   NULL,
279   EFI_USB2_HC_PROTOCOL_GUID,
280   //
281   // Debugger Support
282   //
283   L"DebugSupport",
284   SEnvDebugSupport,
285   NULL,
286   EFI_DEBUG_SUPPORT_PROTOCOL_GUID,
287   L"DebugPort",
288   NULL,
289   NULL,
290   EFI_DEBUGPORT_PROTOCOL_GUID,
291   //
292   // Decompression Algorithm
293   //
294   L"Decompress",
295   NULL,
296   NULL,
297   EFI_DECOMPRESS_PROTOCOL_GUID,
298   //
299   // ACPI
300   //
301   L"AcpiTable",
302   NULL,
303   NULL,
304   EFI_ACPI_TABLE_PROTOCOL_GUID,
305   //
306   // EBC
307   //
308   L"EbcInterp",
309   NULL,
310   NULL,
311   EFI_EBC_INTERPRETER_PROTOCOL_GUID,
312   //
313   // SNP, PXE, BIS
314   //
315   L"Net",
316   NULL,
317   NULL,
318   EFI_SIMPLE_NETWORK_PROTOCOL_GUID,
319   L"Nii",
320   NULL,
321   NULL,
322   EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL_GUID,
323   L"Pxebc",
324   NULL,
325   NULL,
326   EFI_PXE_BASE_CODE_PROTOCOL_GUID,
327   L"PxebcCallback",
328   NULL,
329   NULL,
330   EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL_GUID,
331   L"Bis",
332   NULL,
333   NULL,
334   EFI_BIS_PROTOCOL_GUID,
335   //
336   // Managed Network
337   //
338   L"MNPSb",
339   NULL,
340   NULL,
341   EFI_MANAGED_NETWORK_SERVICE_BINDING_PROTOCOL_GUID,
342   L"MNP",
343   NULL,
344   NULL,
345   EFI_MANAGED_NETWORK_PROTOCOL_GUID,
346   //
347   // ARP, DHCPv4
348   //
349   L"ARPSb",
350   NULL,
351   NULL,
352   EFI_ARP_SERVICE_BINDING_PROTOCOL_GUID,
353   L"ARP",
354   NULL,
355   NULL,
356   EFI_ARP_PROTOCOL_GUID,
357   L"DHCPv4Sb",
358   NULL,
359   NULL,
360   EFI_DHCP4_SERVICE_BINDING_PROTOCOL_GUID,
361   L"DHCPv4",
362   NULL,
363   NULL,
364   EFI_DHCP4_PROTOCOL_GUID,
365   //
366   // TCPv4, IPv4 and Configuration
367   //
368   L"TCPv4Sb",
369   NULL,
370   NULL,
371   EFI_TCP4_SERVICE_BINDING_PROTOCOL_GUID,
372   L"TCPv4",
373   NULL,
374   NULL,
375   EFI_TCP4_PROTOCOL_GUID,
376   L"IPv4Sb",
377   NULL,
378   NULL,
379   EFI_IP4_SERVICE_BINDING_PROTOCOL_GUID,
380   L"IPv4",
381   NULL,
382   NULL,
383   EFI_IP4_PROTOCOL_GUID,
384   L"IPv4Config",
385   NULL,
386   NULL,
387   EFI_IP4_CONFIG_PROTOCOL_GUID,
388   //
389   // UDPv4, MTFTPv4
390   //
391   L"UDPv4Sb",
392   NULL,
393   NULL,
394   EFI_UDP4_SERVICE_BINDING_PROTOCOL_GUID,
395   L"UDPv4",
396   NULL,
397   NULL,
398   EFI_UDP4_PROTOCOL_GUID,
399   L"MTFTPv4Sb",
400   NULL,
401   NULL,
402   EFI_MTFTP4_SERVICE_BINDING_PROTOCOL_GUID,
403   L"MTFTPv4",
404   NULL,
405   NULL,
406   EFI_MTFTP4_PROTOCOL_GUID,
407   //
408   // Security
409   //
410   L"AuthInfo",
411   NULL,
412   NULL,
413   EFI_AUTHENTICATION_INFO_PROTOCOL_GUID,
414   L"HashSb",
415   NULL,
416   NULL,
417   EFI_HASH_SERVICE_BINDING_PROTOCOL,
418   L"Hash",
419   NULL,
420   NULL,
421   EFI_HASH_PROTOCOL_GUID,
422   //
423   // HII 
424   //
425 #if (EFI_SPECIFICATION_VERSION >= 0x0002000A)
426   L"HiiFont",
427   NULL,
428   NULL,
429   EFI_HII_FONT_PROTOCOL_GUID,
430   L"HiiString",
431   NULL,
432   NULL,
433   EFI_HII_STRING_PROTOCOL_GUID,
434   L"HiiImage",
435   NULL,
436   NULL,
437   EFI_HII_IMAGE_PROTOCOL_GUID,
438   L"HiiDatabase",
439   NULL,
440   NULL,
441   EFI_HII_DATABASE_PROTOCOL_GUID,
442   //
443   // HII Configuration Processing and Browser
444   //
445   L"HiiConfRouting",
446   NULL,
447   NULL,
448   EFI_HII_CONFIG_ROUTING_PROTOCOL_GUID,
449   L"HiiConfAccess",
450   NULL,
451   NULL,
452   EFI_HII_CONFIG_ACCESS_PROTOCOL_GUID,
453   L"FormBrowser2",
454   NULL,
455   NULL,
456   EFI_FORM_BROWSER2_PROTOCOL_GUID,
457 #else
458   L"Hii",
459   NULL,
460   NULL,
461   EFI_HII_PROTOCOL_GUID,
462   L"FormBrowser",
463   NULL,
464   NULL,
465   EFI_FORM_BROWSER_PROTOCOL_GUID,
466   L"FormCallback",
467   NULL,
468   NULL,
469   EFI_FORM_CALLBACK_PROTOCOL_GUID,
470 #endif
471   //
472   // Shell Specific
473   //
474   L"ShellInt",
475   NULL,
476   NULL,
477   SHELL_INTERFACE_PROTOCOL,
478   L"SEnv",
479   NULL,
480   NULL,
481   ENVIRONMENT_VARIABLE_ID,
482   L"ShellProtId",
483   NULL,
484   NULL,
485   PROTOCOL_ID_ID,
486   L"ShellDevPathMap",
487   NULL,
488   NULL,
489   DEVICE_PATH_MAPPING_ID,
490   L"ShellAlias",
491   NULL,
492   NULL,
493   ALIAS_ID,
494   L"G0",
495   NULL,
496   NULL,
497   {
498     0,
499     0,
500     0,
501     0,
502     0,
503     0,
504     0,
505     0,
506     0,
507     0,
508     0
509   },
510   //
511   // Deprecated
512   //
513   L"DevIo",
514   NULL,
515   NULL,
516   EFI_DEVICE_IO_PROTOCOL_GUID,
517   L"Tcp",
518   NULL,
519   NULL,
520   EFI_TCP_PROTOCOL_GUID,
521   L"UgaDraw",
522   NULL,
523   NULL,
524   EFI_UGA_DRAW_PROTOCOL_GUID,
525   L"UgaIo",
526   NULL,
527   NULL,
528   EFI_UGA_IO_PROTOCOL_GUID,
529   L"Efi",
530   NULL,
531   NULL,
532   EFI_GLOBAL_VARIABLE_GUID,
533   L"FileSysInfo",
534   NULL,
535   NULL,
536   EFI_FILE_SYSTEM_INFO_ID_GUID,
537   L"ESP",
538   NULL,
539   NULL,
540   EFI_PART_TYPE_EFI_SYSTEM_PART_GUID,
541   L"GPT MBR",
542   NULL,
543   NULL,
544   EFI_PART_TYPE_LEGACY_MBR_GUID,
545   L"Configuration",
546   NULL,
547   NULL,
548   EFI_DRIVER_CONFIGURATION_PROTOCOL_GUID,
549   L"Configuration2",
550   NULL,
551   NULL,
552   EFI_DRIVER_CONFIGURATION2_PROTOCOL_GUID,
553   L"IsaIo",
554   SEnvIsaIo,
555   NULL,
556   EFI_ISA_IO_PROTOCOL_GUID,
557   L"IsaAcpi",
558   NULL,
559   NULL,
560   EFI_ISA_ACPI_PROTOCOL_GUID,
561   //
562   // NT32
563   //
564 #if (PLATFORM == NT32)
565   L"WinNtThunk",
566   NULL,
567   NULL,
568   LOCAL_EFI_WIN_NT_THUNK_PROTOCOL_GUID,
569   L"WinNtDriverIo",
570   NULL,
571   NULL,
572   LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID,
573   L"SerialPrivate",
574   NULL,
575   NULL,
576   LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID,
577 #endif
578
579   L"Unknown Device",
580   NULL,
581   NULL,
582   UNKNOWN_DEVICE_GUID,
583   NULL
584 };
585
586 //
587 // SEnvProtocolInfo - A list of all known protocol info structures
588 //
589 EFI_LIST_ENTRY  SEnvProtocolInfo;
590 SHELL_VAR_CHECK_ITEM    DHCheckList[] = {
591   {
592     L"-p",
593     0x01,
594     0,
595     FlagTypeNeedVar
596   },
597   {
598     L"-l",
599     0x02,
600     0,
601     FlagTypeNeedVar
602   },
603   {
604     L"-b",
605     0x04,
606     0,
607     FlagTypeSingle
608   },
609   {
610     L"-d",
611     0x08,
612     0,
613     FlagTypeSingle
614   },
615   {
616     L"-v",
617     0x10,
618     0,
619     FlagTypeSingle
620   },
621   {
622     L"-?",
623     0x20,
624     0,
625     FlagTypeSingle
626   },
627   {
628     NULL,
629     0,
630     0,
631     FALSE
632   }
633 };
634
635 //
636 //
637 //
638 VOID
639 SEnvInitProtocolInfo (
640   VOID
641   )
642 /*++
643
644 Routine Description:
645
646 Arguments:
647
648 Returns:
649
650 --*/
651 {
652   //
653   // Initialize SEnvProtocolInfo linked list
654   //
655   InitializeListHead (&SEnvProtocolInfo);
656 }
657
658 VOID
659 SEnvLoadInternalProtInfo (
660   VOID
661   )
662 /*++
663
664 Routine Description:
665
666   Initialize internal protocol handlers.
667
668 Arguments:
669
670 Returns:
671
672 --*/
673 {
674   UINTN Index;
675
676   //
677   // Walk through the SEnvInternalProtocolInfo[] array
678   // add each protocol info to a linked list
679   //
680   for (Index = 0; SEnvInternalProtocolInfo[Index].IdString; Index += 1) {
681     SEnvAddProtocol (
682       &SEnvInternalProtocolInfo[Index].ProtocolId,
683       SEnvInternalProtocolInfo[Index].DumpToken,
684       SEnvInternalProtocolInfo[Index].DumpInfo,
685       SEnvInternalProtocolInfo[Index].IdString
686       );
687   }
688 }
689
690 PROTOCOL_INFO *
691 SEnvGetProtById (
692   IN EFI_GUID         *Protocol,
693   IN BOOLEAN          GenId
694   )
695 /*++
696
697 Routine Description:
698
699   Locate a protocol handle by guid.
700
701 Arguments:
702
703   Protocol - The protocol guid
704   GenId    - Is Gen the ID
705
706 Returns:
707
708 --*/
709 {
710   PROTOCOL_INFO   *Prot;
711   EFI_LIST_ENTRY  *Link;
712   UINTN           LastId;
713   UINTN           Id;
714   CHAR16          s[40];
715
716   ASSERT_LOCKED (&SEnvGuidLock);
717
718   //
719   // Find the protocol entry for this id
720   //
721   LastId = 0;
722   for (Link = SEnvProtocolInfo.Flink; Link != &SEnvProtocolInfo; Link = Link->Flink) {
723     Prot = CR (Link, PROTOCOL_INFO, Link, PROTOCOL_INFO_SIGNATURE);
724     if (CompareGuid (&Prot->ProtocolId, Protocol) == 0) {
725       return Prot;
726     }
727
728     if (Prot->IdString[0] == 'g') {
729       Id      = Atoi (Prot->IdString + 1);
730       LastId  = Id > LastId ? Id : LastId;
731     }
732   }
733   //
734   // If the protocol id is not found, generate a string for it if needed
735   //
736   Prot = NULL;
737   if (GenId) {
738     SPrint (s, sizeof (s), L"g%d", LastId + 1);
739     Prot = AllocateZeroPool (sizeof (PROTOCOL_INFO));
740     if (Prot) {
741       Prot->Signature = PROTOCOL_INFO_SIGNATURE;
742       CopyMem (&Prot->ProtocolId, Protocol, sizeof (EFI_GUID));
743       Prot->IdString = StrDuplicate (s);
744       InsertTailList (&SEnvProtocolInfo, &Prot->Link);
745     }
746   }
747
748   return Prot;
749 }
750
751 PROTOCOL_INFO *
752 SEnvGetProtByStr (
753   IN CHAR16           *Str
754   )
755 /*++
756
757 Routine Description:
758
759 Arguments:
760
761   Str  - The string
762
763 Returns:
764
765 --*/
766 {
767   PROTOCOL_INFO   *Prot;
768   EFI_LIST_ENTRY  *Link;
769   UINTN           Index;
770   EFI_GUID        Guid;
771   CHAR16          c;
772   CHAR16          *Ptr;
773
774   ASSERT_LOCKED (&SEnvGuidLock);
775
776   //
777   // Search for short name match
778   //
779   for (Link = SEnvProtocolInfo.Flink; Link != &SEnvProtocolInfo; Link = Link->Flink) {
780     Prot = CR (Link, PROTOCOL_INFO, Link, PROTOCOL_INFO_SIGNATURE);
781     if (StriCmp (Prot->IdString, Str) == 0) {
782       return Prot;
783     }
784   }
785   //
786   // Convert Str to guid and then match
787   //
788   if (StrLen (Str) == 36 && Str[9] == '-' && Str[19] == '-' && Str[24] == '-') {
789     Guid.Data1  = (UINT32) Xtoi (Str + 0);
790     Guid.Data2  = (UINT16) Xtoi (Str + 10);
791     Guid.Data3  = (UINT16) Xtoi (Str + 15);
792     for (Index = 0; Index < 8; Index++) {
793       Ptr               = Str + 25 + Index * 2;
794       c                 = Ptr[3];
795       Ptr[3]            = 0;
796       Guid.Data4[Index] = (UINT8) Xtoi (Ptr);
797       Ptr[3]            = c;
798     }
799
800     for (Link = SEnvProtocolInfo.Flink; Link != &SEnvProtocolInfo; Link = Link->Flink) {
801       Prot = CR (Link, PROTOCOL_INFO, Link, PROTOCOL_INFO_SIGNATURE);
802       if (CompareGuid (&Prot->ProtocolId, &Guid) == 0) {
803         return Prot;
804       }
805     }
806   }
807
808   return NULL;
809 }
810
811 EFI_STATUS
812 SEnvIGetProtID (
813   IN CHAR16           *Str,
814   OUT EFI_GUID        *ProtId
815   )
816 /*++
817
818 Routine Description:
819
820 Arguments:
821
822   Str       - The string
823   ProtID    - The protocol guid
824
825 Returns:
826
827 --*/
828 {
829   PROTOCOL_INFO *Prot;
830   EFI_STATUS    Status;
831
832   AcquireLock (&SEnvGuidLock);
833
834   Status = EFI_NOT_FOUND;
835   CopyMem (ProtId, &NullGuid, sizeof (EFI_GUID));
836
837   //
838   // Get protocol id by string
839   //
840   Prot = SEnvGetProtByStr (Str);
841   if (Prot) {
842     CopyMem (ProtId, &Prot->ProtocolId, sizeof (EFI_GUID));
843     Status = EFI_SUCCESS;
844   }
845
846   ReleaseLock (&SEnvGuidLock);
847
848   return Status;
849 }
850
851 VOID
852 EFIAPI
853 SEnvAddProtocol (
854   IN EFI_GUID                                 *Protocol,
855   IN SHELLENV_DUMP_PROTOCOL_INFO              DumpToken OPTIONAL,
856   IN SHELLENV_DUMP_PROTOCOL_INFO              DumpInfo OPTIONAL,
857   IN CHAR16                                   *IdString
858   )
859 /*++
860
861 Routine Description:
862
863   Published interface to add protocol handlers.
864
865 Arguments:
866
867   Protocol  - The protocol
868   DumpToken - The dump token
869   DumpInfo  - The dump infomation
870   IdString  - The ID string
871
872 Returns:
873
874 --*/
875 {
876   SEnvIAddProtocol (TRUE, Protocol, DumpToken, DumpInfo, IdString);
877 }
878
879 VOID
880 SEnvIAddProtocol (
881   IN BOOLEAN                                  SaveId,
882   IN EFI_GUID                                 *Protocol,
883   IN SHELLENV_DUMP_PROTOCOL_INFO              DumpToken OPTIONAL,
884   IN SHELLENV_DUMP_PROTOCOL_INFO              DumpInfo OPTIONAL,
885   IN CHAR16                                   *IdString
886   )
887 /*++
888
889 Routine Description:
890
891   Internal interface to add protocol handlers.
892
893 Arguments:
894
895   SaveId    - Is save the ID
896   Protocol  - The protocol
897   DumpToken - The dump token
898   DumpInfo  - The dump infomation
899   IdString  - The ID string
900
901 Returns:
902
903 --*/
904 {
905   PROTOCOL_INFO *Prot;
906   BOOLEAN       StoreInfo;
907   CHAR16        *ObsoleteName;
908
909   ObsoleteName  = NULL;
910   StoreInfo     = FALSE;
911
912   AcquireLock (&SEnvGuidLock);
913
914   //
915   // Get the current protocol info
916   //
917   Prot = SEnvGetProtById (Protocol, FALSE);
918
919   if (Prot) {
920     //
921     // If the name has changed, delete the old variable
922     //
923     if (StriCmp (Prot->IdString, IdString)) {
924       ObsoleteName  = Prot->IdString;
925       StoreInfo     = TRUE;
926     } else {
927       FreePool (Prot->IdString);
928     }
929
930     Prot->IdString = NULL;
931   } else {
932     //
933     // Allocate new protocol info
934     //
935     Prot            = AllocateZeroPool (sizeof (PROTOCOL_INFO));
936     Prot->Signature = PROTOCOL_INFO_SIGNATURE;
937     StoreInfo       = TRUE;
938   }
939   //
940   // Apply any updates to the protocol info
941   //
942   if (Prot) {
943     CopyMem (&Prot->ProtocolId, Protocol, sizeof (EFI_GUID));
944     Prot->IdString  = StrDuplicate (IdString);
945     Prot->DumpToken = DumpToken;
946     Prot->DumpInfo  = DumpInfo;
947
948     if (Prot->Link.Flink) {
949       RemoveEntryList (&Prot->Link);
950     }
951
952     InsertTailList (&SEnvProtocolInfo, &Prot->Link);
953   }
954
955   ReleaseLock (&SEnvGuidLock);
956
957   //
958   // If the name changed, delete the old name
959   //
960   if (ObsoleteName) {
961     RT->SetVariable (ObsoleteName, &SEnvProtId, 0, 0, NULL);
962     FreePool (ObsoleteName);
963   }
964   //
965   // Store the protocol idstring to a variable
966   //
967   if (Prot && StoreInfo && SaveId) {
968     RT->SetVariable (
969           Prot->IdString,
970           &SEnvProtId,
971           EFI_VARIABLE_BOOTSERVICE_ACCESS,  // | EFI_VARIABLE_NON_VOLATILE,
972           sizeof (EFI_GUID),
973           &Prot->ProtocolId
974           );
975   }
976 }
977
978 VOID
979 SEnvLoadHandleProtocolInfo (
980   IN EFI_GUID         *SkipProtocol
981   )
982 /*++
983
984 Routine Description:
985
986   Code to load the internal handle cross-reference info for each protocol.
987
988 Arguments:
989
990   SkipProtocol  - Skiped protocol
991
992 Returns:
993
994 --*/
995 {
996   PROTOCOL_INFO   *Prot;
997   EFI_LIST_ENTRY  *Link;
998
999   AcquireLock (&SEnvGuidLock);
1000
1001   for (Link = SEnvProtocolInfo.Flink; Link != &SEnvProtocolInfo; Link = Link->Flink) {
1002     Prot = CR (Link, PROTOCOL_INFO, Link, PROTOCOL_INFO_SIGNATURE);
1003     //
1004     // Load internal handle cross-reference info for each protocol
1005     //
1006     if (!SkipProtocol || CompareGuid (SkipProtocol, &Prot->ProtocolId) != 0) {
1007       LibLocateHandle (
1008         ByProtocol,
1009         &Prot->ProtocolId,
1010         NULL,
1011         &Prot->NoHandles,
1012         &Prot->Handles
1013         );
1014     }
1015   }
1016
1017   ReleaseLock (&SEnvGuidLock);
1018 }
1019
1020 VOID
1021 SEnvFreeHandleProtocolInfo (
1022   VOID
1023   )
1024 /*++
1025
1026 Routine Description:
1027
1028   Free the internal handle cross-reference protocol info.
1029
1030 Arguments:
1031
1032 Returns:
1033
1034 --*/
1035 {
1036   PROTOCOL_INFO   *Prot;
1037   EFI_LIST_ENTRY  *Link;
1038
1039   AcquireLock (&SEnvGuidLock);
1040
1041   //
1042   // Free all protocol handle info
1043   //
1044   for (Link = SEnvProtocolInfo.Flink; Link != &SEnvProtocolInfo; Link = Link->Flink) {
1045     Prot = CR (Link, PROTOCOL_INFO, Link, PROTOCOL_INFO_SIGNATURE);
1046
1047     if (Prot->NoHandles) {
1048       FreePool (Prot->Handles);
1049       Prot->Handles   = NULL;
1050       Prot->NoHandles = 0;
1051     }
1052   }
1053
1054   ReleaseLock (&SEnvGuidLock);
1055 }
1056
1057 CHAR16 *
1058 SEnvIGetProtocol (
1059   IN EFI_GUID     *ProtocolId,
1060   IN BOOLEAN      GenId
1061   )
1062 /*++
1063
1064 Routine Description:
1065
1066   Published interface to lookup a protocol id string.
1067
1068 Arguments:
1069
1070   ProtocolId - The protocol ID
1071   GenId      - Is generate the ID
1072
1073 Returns:
1074
1075 --*/
1076 {
1077   PROTOCOL_INFO *Prot;
1078   CHAR16        *Id;
1079
1080   ASSERT_LOCKED (&SEnvGuidLock);
1081   Prot  = SEnvGetProtById (ProtocolId, GenId);
1082   Id    = Prot ? Prot->IdString : NULL;
1083   return Id;
1084 }
1085
1086 CHAR16 *
1087 EFIAPI
1088 SEnvGetProtocol (
1089   IN EFI_GUID     *ProtocolId,
1090   IN BOOLEAN      GenId
1091   )
1092 /*++
1093
1094 Routine Description:
1095
1096   Published interface to lookup a protocol id string.
1097
1098 Arguments:
1099
1100   ProtocolId - Protocol ID
1101   GenId      - Is generate the ID
1102
1103 Returns:
1104
1105 --*/
1106 {
1107   CHAR16  *Id;
1108
1109   AcquireLock (&SEnvGuidLock);
1110   Id = SEnvIGetProtocol (ProtocolId, GenId);
1111   ReleaseLock (&SEnvGuidLock);
1112   return Id;
1113 }
1114
1115 UINTN
1116 SEnvGetHandleNumber (
1117   IN  EFI_HANDLE  Handle
1118   )
1119 /*++
1120
1121 Routine Description:
1122
1123 Arguments:
1124
1125   Handle - The handle
1126
1127 Returns:
1128
1129 --*/
1130 {
1131   UINTN HandleNumber;
1132
1133   for (HandleNumber = 0; HandleNumber < SEnvNoHandles; HandleNumber++) {
1134     if (SEnvHandles[HandleNumber] == Handle) {
1135       break;
1136     }
1137   }
1138
1139   if (HandleNumber >= SEnvNoHandles) {
1140     return 0;
1141   }
1142
1143   return HandleNumber + 1;
1144 }
1145
1146 EFI_STATUS
1147 GetDriverName (
1148   EFI_HANDLE  DriverBindingHandle,
1149   UINT8       *Language,
1150   BOOLEAN     ImageName,
1151   CHAR16      **DriverName
1152   )
1153
1154 {
1155   EFI_STATUS                    Status;
1156   EFI_DRIVER_BINDING_PROTOCOL   *DriverBinding;
1157   EFI_LOADED_IMAGE_PROTOCOL     *Image;
1158
1159   *DriverName = NULL;
1160
1161   Status = BS->OpenProtocol (
1162                 DriverBindingHandle,
1163                 &gEfiDriverBindingProtocolGuid,
1164                 (VOID **) &DriverBinding,
1165                 NULL,
1166                 NULL,
1167                 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1168                 );
1169   if (EFI_ERROR (Status)) {
1170     return EFI_SUCCESS;
1171   }
1172
1173   if (ImageName) {
1174     Status = BS->OpenProtocol (
1175                   DriverBinding->ImageHandle,
1176                   &gEfiLoadedImageProtocolGuid,
1177                   (VOID **) &Image,
1178                   NULL,
1179                   NULL,
1180                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
1181                   );
1182     if (!EFI_ERROR (Status)) {
1183       *DriverName = LibDevicePathToStr (Image->FilePath);
1184     }
1185   } else {
1186     LibGetDriverName (DriverBindingHandle, Language, DriverName);
1187   }
1188
1189   return EFI_SUCCESS;
1190 }
1191
1192 EFI_STATUS
1193 SEnvGetDeviceName (
1194   EFI_HANDLE  DeviceHandle,
1195   BOOLEAN     UseComponentName,
1196   BOOLEAN     UseDevicePath,
1197   CHAR8       *Language,
1198   CHAR16      **BestDeviceName,
1199   EFI_STATUS  *ConfigurationStatus,
1200   EFI_STATUS  *DiagnosticsStatus,
1201   BOOLEAN     Display,
1202   UINTN       Indent
1203   )
1204
1205 {
1206   EFI_STATUS                  Status;
1207   UINTN                       HandleIndex;
1208   UINTN                       ParentDriverIndex;
1209   UINTN                       ChildIndex;
1210   UINTN                       DriverBindingHandleCount;
1211   EFI_HANDLE                  *DriverBindingHandleBuffer;
1212   UINTN                       ParentControllerHandleCount;
1213   EFI_HANDLE                  *ParentControllerHandleBuffer;
1214   UINTN                       ParentDriverBindingHandleCount;
1215   EFI_HANDLE                  *ParentDriverBindingHandleBuffer;
1216   UINTN                       ChildControllerHandleCount;
1217   EFI_HANDLE                  *ChildControllerHandleBuffer;
1218   UINTN                       ChildHandleCount;
1219   EFI_HANDLE                  *ChildHandleBuffer;
1220   EFI_DEVICE_PATH_PROTOCOL    *DevicePath;
1221   CHAR16                      *ControllerName;
1222   UINTN                       Index;
1223   BOOLEAN                     First;
1224
1225   *BestDeviceName       = NULL;
1226   ControllerName        = NULL;
1227   *ConfigurationStatus  = EFI_NOT_FOUND;
1228   *DiagnosticsStatus    = EFI_NOT_FOUND;
1229   First                 = TRUE;
1230
1231   Status = LibGetManagingDriverBindingHandles (
1232             DeviceHandle,
1233             &DriverBindingHandleCount,
1234             &DriverBindingHandleBuffer
1235             );
1236
1237   Status = LibGetParentControllerHandles (
1238             DeviceHandle,
1239             &ParentControllerHandleCount,
1240             &ParentControllerHandleBuffer
1241             );
1242
1243   Status = LibGetChildControllerHandles (
1244             DeviceHandle,
1245             &ChildControllerHandleCount,
1246             &ChildControllerHandleBuffer
1247             );
1248
1249   for (HandleIndex = 0; HandleIndex < DriverBindingHandleCount; HandleIndex++) {
1250
1251     Status = BS->OpenProtocol (
1252                   DriverBindingHandleBuffer[HandleIndex],
1253                   &gEfiDriverConfigurationProtocolGuid,
1254                   NULL,
1255                   NULL,
1256                   NULL,
1257                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
1258                   );
1259     if (!EFI_ERROR (Status)) {
1260       *ConfigurationStatus = EFI_SUCCESS;
1261     }
1262
1263     Status = BS->OpenProtocol (
1264                   DriverBindingHandleBuffer[HandleIndex],
1265                   &gEfiDriverConfiguration2ProtocolGuid,
1266                   NULL,
1267                   NULL,
1268                   NULL,
1269                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
1270                   );
1271     if (!EFI_ERROR (Status)) {
1272       *ConfigurationStatus = EFI_SUCCESS;
1273     }
1274
1275     Status = BS->OpenProtocol (
1276                   DriverBindingHandleBuffer[HandleIndex],
1277                   &gEfiDriverDiagnosticsProtocolGuid,
1278                   NULL,
1279                   NULL,
1280                   NULL,
1281                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
1282                   );
1283     if (!EFI_ERROR (Status)) {
1284       *DiagnosticsStatus = EFI_SUCCESS;
1285     }
1286
1287     Status = BS->OpenProtocol (
1288                   DriverBindingHandleBuffer[HandleIndex],
1289                   &gEfiDriverDiagnostics2ProtocolGuid,
1290                   NULL,
1291                   NULL,
1292                   NULL,
1293                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
1294                   );
1295     if (!EFI_ERROR (Status)) {
1296       *DiagnosticsStatus = EFI_SUCCESS;
1297     }
1298
1299     Status = LibGetControllerName (
1300                DriverBindingHandleBuffer[HandleIndex],
1301                DeviceHandle,
1302                NULL,
1303                Language,
1304                &ControllerName
1305                );
1306     if (EFI_ERROR (Status)) {
1307       continue;
1308     }
1309
1310     if (Display) {
1311       if (!First) {
1312         Print (L"\n");
1313         for (Index = 0; Index < Indent; Index++) {
1314           Print (L" ");
1315         }
1316       }
1317
1318       PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_ONE_VAR_HS_NO_SPACES), HiiEnvHandle, ControllerName);
1319       First = FALSE;
1320     }
1321
1322     if (UseComponentName) {
1323       if (*BestDeviceName == NULL) {
1324         *BestDeviceName = StrDuplicate (ControllerName);
1325       }
1326     }
1327   }
1328
1329   for (HandleIndex = 0; HandleIndex < ParentControllerHandleCount; HandleIndex++) {
1330
1331     Status = LibGetManagingDriverBindingHandles (
1332               ParentControllerHandleBuffer[HandleIndex],
1333               &ParentDriverBindingHandleCount,
1334               &ParentDriverBindingHandleBuffer
1335               );
1336     if (EFI_ERROR (Status)) {
1337       continue;
1338     }
1339
1340     for (ParentDriverIndex = 0; ParentDriverIndex < ParentDriverBindingHandleCount; ParentDriverIndex++) {
1341
1342       Status = LibGetManagedChildControllerHandles (
1343                 ParentDriverBindingHandleBuffer[ParentDriverIndex],
1344                 ParentControllerHandleBuffer[HandleIndex],
1345                 &ChildHandleCount,
1346                 &ChildHandleBuffer
1347                 );
1348       if (EFI_ERROR (Status)) {
1349         continue;
1350       }
1351
1352       for (ChildIndex = 0; ChildIndex < ChildHandleCount; ChildIndex++) {
1353         if (ChildHandleBuffer[ChildIndex] == DeviceHandle) {
1354
1355           Status = BS->OpenProtocol (
1356                         ParentDriverBindingHandleBuffer[ParentDriverIndex],
1357                         &gEfiDriverConfigurationProtocolGuid,
1358                         NULL,
1359                         NULL,
1360                         NULL,
1361                         EFI_OPEN_PROTOCOL_TEST_PROTOCOL
1362                         );
1363           if (!EFI_ERROR (Status)) {
1364             *ConfigurationStatus = EFI_SUCCESS;
1365           }
1366
1367           Status = BS->OpenProtocol (
1368                         ParentDriverBindingHandleBuffer[ParentDriverIndex],
1369                         &gEfiDriverConfiguration2ProtocolGuid,
1370                         NULL,
1371                         NULL,
1372                         NULL,
1373                         EFI_OPEN_PROTOCOL_TEST_PROTOCOL
1374                         );
1375           if (!EFI_ERROR (Status)) {
1376             *ConfigurationStatus = EFI_SUCCESS;
1377           }
1378
1379           Status = BS->OpenProtocol (
1380                         ParentDriverBindingHandleBuffer[ParentDriverIndex],
1381                         &gEfiDriverDiagnosticsProtocolGuid,
1382                         NULL,
1383                         NULL,
1384                         NULL,
1385                         EFI_OPEN_PROTOCOL_TEST_PROTOCOL
1386                         );
1387           if (!EFI_ERROR (Status)) {
1388             *DiagnosticsStatus = EFI_SUCCESS;
1389           }
1390
1391           Status = BS->OpenProtocol (
1392                         ParentDriverBindingHandleBuffer[ParentDriverIndex],
1393                         &gEfiDriverDiagnostics2ProtocolGuid,
1394                         NULL,
1395                         NULL,
1396                         NULL,
1397                         EFI_OPEN_PROTOCOL_TEST_PROTOCOL
1398                         );
1399           if (!EFI_ERROR (Status)) {
1400             *DiagnosticsStatus = EFI_SUCCESS;
1401           }
1402
1403           Status = LibGetControllerName (
1404                      ParentDriverBindingHandleBuffer[ParentDriverIndex],
1405                      ParentControllerHandleBuffer[HandleIndex],
1406                      DeviceHandle,
1407                      Language,
1408                      &ControllerName
1409                      );
1410           if (EFI_ERROR (Status)) {
1411             continue;
1412           }
1413
1414           if (Display) {
1415             if (!First) {
1416               Print (L"\n");
1417               for (Index = 0; Index < Indent; Index++) {
1418                 Print (L" ");
1419               }
1420             }
1421
1422             PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_ONE_VAR_HS_NO_SPACES), HiiEnvHandle, ControllerName);
1423             First = FALSE;
1424           }
1425
1426           if (UseComponentName) {
1427             if (*BestDeviceName == NULL) {
1428               *BestDeviceName = StrDuplicate (ControllerName);
1429             }
1430           }
1431         }
1432       }
1433
1434       FreePool (ChildHandleBuffer);
1435     }
1436
1437     FreePool (ParentDriverBindingHandleBuffer);
1438   }
1439
1440   if (UseDevicePath) {
1441     if (*BestDeviceName == NULL) {
1442       Status = BS->OpenProtocol (
1443                     DeviceHandle,
1444                     &gEfiDevicePathProtocolGuid,
1445                     (VOID **) &DevicePath,
1446                     NULL,
1447                     NULL,
1448                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
1449                     );
1450
1451       if (!EFI_ERROR (Status)) {
1452         *BestDeviceName = LibDevicePathToStr (DevicePath);
1453       }
1454     }
1455   }
1456
1457   if (DriverBindingHandleCount != 0) {
1458     FreePool (DriverBindingHandleBuffer);
1459   }
1460
1461   if (ParentControllerHandleCount != 0) {
1462     FreePool (ParentControllerHandleBuffer);
1463   }
1464
1465   if (ChildControllerHandleCount != 0) {
1466     FreePool (ChildControllerHandleBuffer);
1467
1468   }
1469
1470   return EFI_SUCCESS;
1471 }
1472
1473 EFI_STATUS
1474 DisplayDriverModelHandle (
1475   IN EFI_HANDLE  Handle,
1476   IN BOOLEAN     BestName,
1477   IN CHAR8       *Language
1478   )
1479 /*++
1480
1481 Routine Description:
1482
1483 Arguments:
1484
1485   Handle   - The handle
1486   BestName - The best name
1487   Language - The language
1488
1489 Returns:
1490
1491 --*/
1492 {
1493   EFI_STATUS                  Status;
1494   EFI_STATUS                  ConfigurationStatus;
1495   EFI_STATUS                  DiagnosticsStatus;
1496   UINTN                       DriverBindingHandleCount;
1497   EFI_HANDLE                  *DriverBindingHandleBuffer;
1498   UINTN                       ParentControllerHandleCount;
1499   EFI_HANDLE                  *ParentControllerHandleBuffer;
1500   UINTN                       ChildControllerHandleCount;
1501   EFI_HANDLE                  *ChildControllerHandleBuffer;
1502   CHAR16                      *BestDeviceName;
1503   EFI_DEVICE_PATH_PROTOCOL    *DevicePath;
1504   UINTN                       Index;
1505   CHAR16                      *DriverName;
1506   EFI_DRIVER_BINDING_PROTOCOL *DriverBinding;
1507   UINTN                       NumberOfChildren;
1508   UINTN                       HandleIndex;
1509   UINTN                       ControllerHandleCount;
1510   EFI_HANDLE                  *ControllerHandleBuffer;
1511   UINTN                       ChildIndex;
1512   BOOLEAN                     Image;
1513
1514   //
1515   // See if Handle is a device handle and display its details.
1516   //
1517   DriverBindingHandleBuffer = NULL;
1518   Status = LibGetManagingDriverBindingHandles (
1519             Handle,
1520             &DriverBindingHandleCount,
1521             &DriverBindingHandleBuffer
1522             );
1523
1524   ParentControllerHandleBuffer = NULL;
1525   Status = LibGetParentControllerHandles (
1526             Handle,
1527             &ParentControllerHandleCount,
1528             &ParentControllerHandleBuffer
1529             );
1530
1531   ChildControllerHandleBuffer = NULL;
1532   Status = LibGetChildControllerHandles (
1533             Handle,
1534             &ChildControllerHandleCount,
1535             &ChildControllerHandleBuffer
1536             );
1537
1538   if (DriverBindingHandleCount > 0 || ParentControllerHandleCount > 0 || ChildControllerHandleCount > 0) {
1539
1540     DevicePath      = NULL;
1541     BestDeviceName  = NULL;
1542     Status          = BS->HandleProtocol (Handle, &gEfiDevicePathProtocolGuid, &DevicePath);
1543
1544     Print (L"\n");
1545     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_CONTROLLER_NAME), HiiEnvHandle);
1546
1547     Status = SEnvGetDeviceName (
1548               Handle,
1549               TRUE,
1550               FALSE,
1551               Language,
1552               &BestDeviceName,
1553               &ConfigurationStatus,
1554               &DiagnosticsStatus,
1555               TRUE,
1556               26
1557               );
1558
1559     if (BestDeviceName == NULL) {
1560       PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_UNKNOWN_2), HiiEnvHandle);
1561     } else {
1562       FreePool (BestDeviceName);
1563       BestDeviceName = NULL;
1564     }
1565
1566     Print (L"\n");
1567
1568     if (DevicePath != NULL) {
1569       PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_DEV_PAATH), HiiEnvHandle, LibDevicePathToStr (DevicePath));
1570     } else {
1571       PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_DEV_PATH_2), HiiEnvHandle);
1572     }
1573
1574     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_CONTROLLER_TYPE), HiiEnvHandle);
1575     if (ParentControllerHandleCount == 0) {
1576       PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_ROOT), HiiEnvHandle);
1577     } else if (ChildControllerHandleCount > 0) {
1578       PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_HBUS), HiiEnvHandle);
1579     } else {
1580       PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_HDEVICE), HiiEnvHandle);
1581     }
1582
1583     if (!EFI_ERROR (ConfigurationStatus)) {
1584       PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_CONFIG_HYES), HiiEnvHandle);
1585     } else {
1586       PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_CONFIG_HNO), HiiEnvHandle);
1587     }
1588
1589     if (!EFI_ERROR (DiagnosticsStatus)) {
1590       PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_DIAG_HYES), HiiEnvHandle);
1591     } else {
1592       PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_DIAG_HNO), HiiEnvHandle);
1593     }
1594
1595     if (DriverBindingHandleCount != 0) {
1596       PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_MANAGED_BY), HiiEnvHandle);
1597       for (Index = 0; Index < DriverBindingHandleCount; Index++) {
1598         Image = FALSE;
1599         Status = GetDriverName (
1600                   DriverBindingHandleBuffer[Index],
1601                   Language,
1602                   FALSE,
1603                   &DriverName
1604                   );
1605         if (DriverName == NULL) {
1606           Status = GetDriverName (
1607                     DriverBindingHandleBuffer[Index],
1608                     Language,
1609                     TRUE,
1610                     &DriverName
1611                     );
1612           if (!EFI_ERROR (Status)) {
1613             Image = TRUE;
1614           }
1615         }
1616
1617         if (DriverName == NULL) {
1618           DriverName = L"<UNKNOWN>";
1619         }
1620
1621         if (Image) {
1622           PrintToken (
1623             STRING_TOKEN (STR_SHELLENV_PROTID_DRV_IMAGE),
1624             HiiEnvHandle,
1625             SEnvGetHandleNumber (DriverBindingHandleBuffer[Index]),
1626             DriverName
1627             );
1628         } else {
1629           PrintToken (
1630             STRING_TOKEN (STR_SHELLENV_PROTID_DRV_HS),
1631             HiiEnvHandle,
1632             SEnvGetHandleNumber (DriverBindingHandleBuffer[Index]),
1633             DriverName
1634             );
1635         }
1636       }
1637     } else {
1638       PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_MANAGED_BY_NONE), HiiEnvHandle);
1639     }
1640
1641     if (ParentControllerHandleCount != 0) {
1642       PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_PARENT_CONTROLLERS), HiiEnvHandle);
1643       for (Index = 0; Index < ParentControllerHandleCount; Index++) {
1644         Status = SEnvGetDeviceName (
1645                   ParentControllerHandleBuffer[Index],
1646                   BestName,
1647                   TRUE,
1648                   Language,
1649                   &BestDeviceName,
1650                   &ConfigurationStatus,
1651                   &DiagnosticsStatus,
1652                   FALSE,
1653                   0
1654                   );
1655         if (BestDeviceName == NULL) {
1656           BestDeviceName = StrDuplicate (L"<UNKNOWN>");
1657         }
1658
1659         PrintToken (
1660           STRING_TOKEN (STR_SHELLENV_PROTID_PARENT),
1661           HiiEnvHandle,
1662           SEnvGetHandleNumber (ParentControllerHandleBuffer[Index]),
1663           BestDeviceName
1664           );
1665         FreePool (BestDeviceName);
1666         BestDeviceName = NULL;
1667       }
1668     } else {
1669       PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_PARENT_CONT_NONE), HiiEnvHandle);
1670     }
1671
1672     if (ChildControllerHandleCount != 0) {
1673       PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_CHILD_CONTROL), HiiEnvHandle);
1674       for (Index = 0; Index < ChildControllerHandleCount; Index++) {
1675         Status = SEnvGetDeviceName (
1676                   ChildControllerHandleBuffer[Index],
1677                   BestName,
1678                   TRUE,
1679                   Language,
1680                   &BestDeviceName,
1681                   &ConfigurationStatus,
1682                   &DiagnosticsStatus,
1683                   FALSE,
1684                   0
1685                   );
1686         if (BestDeviceName == NULL) {
1687           BestDeviceName = StrDuplicate (L"<UNKNOWN>");
1688         }
1689
1690         PrintToken (
1691           STRING_TOKEN (STR_SHELLENV_PROTID_CHILD),
1692           HiiEnvHandle,
1693           SEnvGetHandleNumber (ChildControllerHandleBuffer[Index]),
1694           BestDeviceName
1695           );
1696         FreePool (BestDeviceName);
1697         BestDeviceName = NULL;
1698       }
1699     } else {
1700       PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_CHILD_CONTROL_NONE), HiiEnvHandle);
1701     }
1702   }
1703
1704   Status = EFI_SUCCESS;
1705
1706   if (DriverBindingHandleBuffer) {
1707     FreePool (DriverBindingHandleBuffer);
1708   }
1709
1710   if (ParentControllerHandleBuffer) {
1711     FreePool (ParentControllerHandleBuffer);
1712   }
1713
1714   if (ChildControllerHandleBuffer) {
1715     FreePool (ChildControllerHandleBuffer);
1716   }
1717
1718   if (EFI_ERROR (Status)) {
1719     return Status;
1720   }
1721   //
1722   // See if Handle is a driver binding handle and display its details.
1723   //
1724   Status = BS->OpenProtocol (
1725                 Handle,
1726                 &gEfiDriverBindingProtocolGuid,
1727                 (VOID **) &DriverBinding,
1728                 NULL,
1729                 NULL,
1730                 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1731                 );
1732   if (EFI_ERROR (Status)) {
1733     return EFI_SUCCESS;
1734   }
1735
1736   DiagnosticsStatus = BS->OpenProtocol (
1737                             Handle,
1738                             &gEfiDriverDiagnostics2ProtocolGuid,
1739                             NULL,
1740                             NULL,
1741                             NULL,
1742                             EFI_OPEN_PROTOCOL_TEST_PROTOCOL
1743                             );
1744   if (EFI_ERROR (DiagnosticsStatus)) {
1745     DiagnosticsStatus = BS->OpenProtocol (
1746                               Handle,
1747                               &gEfiDriverDiagnosticsProtocolGuid,
1748                               NULL,
1749                               NULL,
1750                               NULL,
1751                               EFI_OPEN_PROTOCOL_TEST_PROTOCOL
1752                               );
1753   }
1754
1755   ConfigurationStatus = BS->OpenProtocol (
1756                               Handle,
1757                               &gEfiDriverConfiguration2ProtocolGuid,
1758                               NULL,
1759                               NULL,
1760                               NULL,
1761                               EFI_OPEN_PROTOCOL_TEST_PROTOCOL
1762                               );
1763   if (EFI_ERROR (DiagnosticsStatus)) {
1764     ConfigurationStatus = BS->OpenProtocol (
1765                                 Handle,
1766                                 &gEfiDriverConfigurationProtocolGuid,
1767                                 NULL,
1768                                 NULL,
1769                                 NULL,
1770                                 EFI_OPEN_PROTOCOL_TEST_PROTOCOL
1771                                 );
1772   }
1773
1774   NumberOfChildren        = 0;
1775   ControllerHandleBuffer  = NULL;
1776   Status = LibGetManagedControllerHandles (
1777             Handle,
1778             &ControllerHandleCount,
1779             &ControllerHandleBuffer
1780             );
1781   if (ControllerHandleCount > 0) {
1782     for (HandleIndex = 0; HandleIndex < ControllerHandleCount; HandleIndex++) {
1783       Status = LibGetManagedChildControllerHandles (
1784                 Handle,
1785                 ControllerHandleBuffer[HandleIndex],
1786                 &ChildControllerHandleCount,
1787                 NULL
1788                 );
1789       NumberOfChildren += ChildControllerHandleCount;
1790     }
1791   }
1792
1793   Status = GetDriverName (
1794             Handle,
1795             Language,
1796             FALSE,
1797             &DriverName
1798             );
1799   Print (L"\n");
1800
1801   if (DriverName != NULL) {
1802     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_DRIVER_NAME), HiiEnvHandle, DriverName);
1803   } else {
1804     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_DRIVER_NAME_NONE), HiiEnvHandle);
1805   }
1806
1807   Status = GetDriverName (
1808             Handle,
1809             Language,
1810             TRUE,
1811             &DriverName
1812             );
1813   if (DriverName != NULL) {
1814     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_IAMGE_NAME), HiiEnvHandle, DriverName);
1815   } else {
1816     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_IMAGE_NAME_NONE), HiiEnvHandle);
1817   }
1818
1819   PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_DRIVER_VERSION), HiiEnvHandle, DriverBinding->Version);
1820
1821   if (NumberOfChildren > 0) {
1822     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_DRIVER_TYPE_HBUS), HiiEnvHandle);
1823   } else if (ControllerHandleCount > 0) {
1824     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_DRIVER_TYPE_HDEVICE), HiiEnvHandle);
1825   } else {
1826     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_DRIVER_TYPE_UNKNOWN), HiiEnvHandle);
1827   }
1828
1829   if (!EFI_ERROR (ConfigurationStatus)) {
1830     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_CONFIG_HYES_2), HiiEnvHandle);
1831   } else {
1832     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_CONFIG_HNO_2), HiiEnvHandle);
1833   }
1834
1835   if (!EFI_ERROR (DiagnosticsStatus)) {
1836     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_DIAGNOSTICS_HYES), HiiEnvHandle);
1837   } else {
1838     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_DIAGNOSTICS_HNO), HiiEnvHandle);
1839   }
1840
1841   if (ControllerHandleCount == 0) {
1842     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_MANAGING_NONE), HiiEnvHandle);
1843   } else {
1844     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_MANAGING), HiiEnvHandle);
1845     for (HandleIndex = 0; HandleIndex < ControllerHandleCount; HandleIndex++) {
1846       Status = SEnvGetDeviceName (
1847                 ControllerHandleBuffer[HandleIndex],
1848                 BestName,
1849                 TRUE,
1850                 Language,
1851                 &BestDeviceName,
1852                 &ConfigurationStatus,
1853                 &DiagnosticsStatus,
1854                 FALSE,
1855                 0
1856                 );
1857       if (BestDeviceName == NULL) {
1858         BestDeviceName = StrDuplicate (L"<UNKNOWN>");
1859       }
1860
1861       PrintToken (
1862         STRING_TOKEN (STR_SHELLENV_PROTID_CTRL_HS),
1863         HiiEnvHandle,
1864         SEnvGetHandleNumber (ControllerHandleBuffer[HandleIndex]),
1865         BestDeviceName
1866         );
1867       FreePool (BestDeviceName);
1868       BestDeviceName = NULL;
1869
1870       Status = LibGetManagedChildControllerHandles (
1871                 Handle,
1872                 ControllerHandleBuffer[HandleIndex],
1873                 &ChildControllerHandleCount,
1874                 &ChildControllerHandleBuffer
1875                 );
1876       if (!EFI_ERROR (Status)) {
1877         for (ChildIndex = 0; ChildIndex < ChildControllerHandleCount; ChildIndex++) {
1878           Status = SEnvGetDeviceName (
1879                     ChildControllerHandleBuffer[ChildIndex],
1880                     BestName,
1881                     TRUE,
1882                     Language,
1883                     &BestDeviceName,
1884                     &ConfigurationStatus,
1885                     &DiagnosticsStatus,
1886                     FALSE,
1887                     0
1888                     );
1889           if (BestDeviceName == NULL) {
1890             BestDeviceName = StrDuplicate (L"<UNKNOWN>");
1891           }
1892
1893           PrintToken (
1894             STRING_TOKEN (STR_SHELLENV_PROTID_CHILD_HS),
1895             HiiEnvHandle,
1896             SEnvGetHandleNumber (ChildControllerHandleBuffer[ChildIndex]),
1897             BestDeviceName
1898             );
1899           FreePool (BestDeviceName);
1900           BestDeviceName = NULL;
1901         }
1902
1903         FreePool (ChildControllerHandleBuffer);
1904       }
1905     }
1906
1907     FreePool (ControllerHandleBuffer);
1908   }
1909
1910   return EFI_SUCCESS;
1911 }
1912
1913 EFI_STATUS
1914 SEnvDHProt (
1915   IN BOOLEAN          Verbose,
1916   IN BOOLEAN          DriverModel,
1917   IN UINTN            HandleNo,
1918   IN EFI_HANDLE       Handle,
1919   IN CHAR8            *Language
1920   )
1921 /*++
1922
1923 Routine Description:
1924
1925 Arguments:
1926
1927   Verbose     - Verbose
1928   DriverModel - Driver model
1929   HandleNo    - Handle number
1930   Handle      - The handle
1931   Language    - The language
1932
1933 Returns:
1934
1935 --*/
1936 {
1937   PROTOCOL_INFO               *Prot;
1938   EFI_LIST_ENTRY              *Link;
1939   VOID                        *Interface;
1940   UINTN                       Index;
1941   UINTN                       Index1;
1942   EFI_STATUS                  Status;
1943   SHELLENV_DUMP_PROTOCOL_INFO Dump;
1944   EFI_GUID                    **ProtocolBuffer;
1945   UINTN                       ProtocolBufferCount;
1946
1947   if (!HandleNo) {
1948     HandleNo = SEnvGetHandleNumber (Handle);
1949   }
1950   //
1951   // Get protocol info by handle
1952   //
1953   ProtocolBuffer = NULL;
1954   Status = BS->ProtocolsPerHandle (
1955                 Handle,
1956                 &ProtocolBuffer,
1957                 &ProtocolBufferCount
1958                 );
1959   if (EFI_ERROR (Status)) {
1960     return EFI_SUCCESS;
1961   }
1962
1963   if (Verbose) {
1964     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_NHANDLE), HiiEnvHandle, HandleNo, Handle);
1965   } else {
1966     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_TWO_VARS_N), HiiEnvHandle, HandleNo, Handle);
1967   }
1968
1969   for (Link = SEnvProtocolInfo.Flink; Link != &SEnvProtocolInfo; Link = Link->Flink) {
1970     Prot = CR (Link, PROTOCOL_INFO, Link, PROTOCOL_INFO_SIGNATURE);
1971     for (Index = 0; Index < Prot->NoHandles; Index++) {
1972       //
1973       // If this handle supports this protocol, dump it
1974       //
1975       if (GetExecutionBreak ()) {
1976         Status = EFI_ABORTED;
1977         goto Done;
1978       }
1979
1980       if (Prot->Handles[Index] == Handle) {
1981         Dump    = Verbose ? Prot->DumpInfo : Prot->DumpToken;
1982         Status  = BS->HandleProtocol (Handle, &Prot->ProtocolId, &Interface);
1983         if (!EFI_ERROR (Status)) {
1984           if (Verbose) {
1985             for (Index1 = 0; Index1 < ProtocolBufferCount; Index1++) {
1986               if (ProtocolBuffer[Index1] != NULL) {
1987                 if (CompareGuid (ProtocolBuffer[Index1], &Prot->ProtocolId) == 0) {
1988                   ProtocolBuffer[Index1] = NULL;
1989                 }
1990               }
1991             }
1992             //
1993             // Dump verbose info
1994             //
1995             PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_TWO_VARS_HS), HiiEnvHandle, Prot->IdString, Interface);
1996             if (Dump != NULL) {
1997               Dump (Handle, Interface);
1998             }
1999
2000             Print (L"\n");
2001           } else {
2002             if (Dump != NULL) {
2003               Dump (Handle, Interface);
2004             } else {
2005               PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_ONE_VAR_HS), HiiEnvHandle, Prot->IdString);
2006             }
2007           }
2008         }
2009       }
2010     }
2011   }
2012
2013   if (DriverModel) {
2014     Status = DisplayDriverModelHandle (Handle, TRUE, Language);
2015     if (EFI_ERROR (Status)) {
2016       goto Done;
2017     }
2018   }
2019   //
2020   // Dump verbose info
2021   //
2022   if (Verbose) {
2023     for (Index1 = 0; Index1 < ProtocolBufferCount; Index1++) {
2024       if (ProtocolBuffer[Index1] != NULL) {
2025         if (GetExecutionBreak ()) {
2026           Status = EFI_ABORTED;
2027           goto Done;
2028         }
2029
2030         Status = BS->HandleProtocol (Handle, ProtocolBuffer[Index1], &Interface);
2031         if (!EFI_ERROR (Status)) {
2032           PrintToken (
2033             STRING_TOKEN (STR_SHELLENV_PROTID_TWO_VARS_HG_NEW),
2034             HiiEnvHandle,
2035             ProtocolBuffer[Index1],
2036             Interface
2037             );
2038         }
2039       }
2040     }
2041
2042     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_ONE_VAR_N), HiiEnvHandle);
2043   } else {
2044     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_ONE_VAR_N_NEWLINE), HiiEnvHandle);
2045   }
2046
2047   Status = EFI_SUCCESS;
2048
2049 Done:
2050   if (ProtocolBuffer != NULL) {
2051     FreePool (ProtocolBuffer);
2052   }
2053
2054   return Status;
2055 }
2056
2057 EFI_STATUS
2058 EFIAPI
2059 SEnvCmdDH (
2060   IN EFI_HANDLE               ImageHandle,
2061   IN EFI_SYSTEM_TABLE         *SystemTable
2062   )
2063 /*++
2064
2065 Routine Description:
2066
2067   Code for internal "DH" command
2068
2069 Arguments:
2070
2071   ImageHandle - The image handle
2072   SystemTable - The system table
2073
2074 Returns:
2075
2076 --*/
2077 {
2078   BOOLEAN                 ByProtocol;
2079   CHAR16                  *Arg;
2080   UINTN                   ArgVar;
2081   EFI_STATUS              Status;
2082   UINTN                   Index;
2083   PROTOCOL_INFO           *Prot;
2084   BOOLEAN                 Verbose;
2085   BOOLEAN                 DriverModel;
2086   CHAR8                   *Language;
2087   SHELL_VAR_CHECK_CODE    RetCode;
2088   CHAR16                  *Useful;
2089   SHELL_ARG_LIST          *Item;
2090   SHELL_VAR_CHECK_PACKAGE ChkPck;
2091
2092   //
2093   // Initialize
2094   //
2095   EFI_SHELL_APP_INIT (ImageHandle, SystemTable);
2096
2097   EnableOutputTabPause ();
2098
2099   Language    = NULL;
2100   Arg         = NULL;
2101   ArgVar      = 0;
2102   ByProtocol  = FALSE;
2103   Status      = EFI_SUCCESS;
2104   ZeroMem (&ChkPck, sizeof (SHELL_VAR_CHECK_PACKAGE));
2105
2106   if (!EFI_PROPER_VERSION (1, 10)) {
2107     PrintToken (
2108       STRING_TOKEN (STR_SHELLENV_GNC_COMMAND_NOT_SUPPORT),
2109       HiiEnvHandle,
2110       L"dh",
2111       EFI_VERSION_1_10
2112       );
2113     Status = EFI_UNSUPPORTED;
2114     goto Done;
2115   }
2116
2117
2118   RetCode = LibCheckVariables (SI, DHCheckList, &ChkPck, &Useful);
2119   if (VarCheckOk != RetCode) {
2120     switch (RetCode) {
2121     case VarCheckConflict:
2122
2123       PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_FLAG_CONFLICT), HiiEnvHandle, L"dh", Useful);
2124       break;
2125
2126     case VarCheckDuplicate:
2127
2128       PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_DUP_FLAG), HiiEnvHandle, L"dh", Useful);
2129       break;
2130
2131     case VarCheckLackValue:
2132
2133       PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_LACK_ARG), HiiEnvHandle, L"dh", Useful);
2134       break;
2135
2136     case VarCheckUnknown:
2137
2138       PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_UNKNOWN_FLAG), HiiEnvHandle, L"dh", Useful);
2139       break;
2140
2141     default:
2142       break;
2143     }
2144     //
2145     // end of switch(RetCode)
2146     //
2147     Status = EFI_INVALID_PARAMETER;
2148     goto Done;
2149   }
2150   //
2151   // Crack args
2152   //
2153   Item = LibCheckVarGetFlag (&ChkPck, L"-b");
2154   if (Item) {
2155     EnablePageBreak (DEFAULT_INIT_ROW, DEFAULT_AUTO_LF);
2156   }
2157
2158   if (LibCheckVarGetFlag (&ChkPck, L"-?") != NULL) {
2159     if (IS_OLD_SHELL) {
2160       PrintToken (STRING_TOKEN (STR_NO_HELP), HiiEnvHandle);
2161       goto Done;
2162     }
2163
2164     if (ChkPck.ValueCount > 0 ||
2165         ChkPck.FlagCount > 2 ||
2166         (2 == ChkPck.FlagCount && !LibCheckVarGetFlag (&ChkPck, L"-b"))
2167         ) {
2168       PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_TOO_MANY), HiiEnvHandle, L"dh");
2169       Status = EFI_INVALID_PARAMETER;
2170       goto Done;
2171     }
2172
2173     PrintToken (STRING_TOKEN (STR_SHELLENV_DH_VERBOSE_HELP), HiiEnvHandle);
2174     Status = EFI_SUCCESS;
2175     goto Done;
2176   }
2177
2178   Verbose     = FALSE;
2179   DriverModel = FALSE;
2180   if (ChkPck.ValueCount > 1) {
2181     PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_TOO_MANY), HiiEnvHandle, L"dh");
2182     Status = EFI_INVALID_PARAMETER;
2183     goto Done;
2184   }
2185  
2186   Item = LibCheckVarGetFlag (&ChkPck, L"-l");
2187   if (Item) {
2188     Language = LibGetCommandLineLanguage (Item->VarStr);
2189   }
2190
2191   Item = LibCheckVarGetFlag (&ChkPck, L"-d");
2192   if (Item) {
2193     DriverModel = TRUE;
2194   }
2195
2196   Item = LibCheckVarGetFlag (&ChkPck, L"-v");
2197   if (Item) {
2198     Verbose = TRUE;
2199   }
2200
2201   Item = LibCheckVarGetFlag (&ChkPck, L"-p");
2202   if (Item) {
2203     Arg         = Item->VarStr;
2204     ByProtocol  = TRUE;
2205     if (ChkPck.ValueCount > 0) {
2206       PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_TOO_MANY), HiiEnvHandle, L"dh");
2207       LibCheckVarFreeVarList (&ChkPck);
2208       Status = EFI_INVALID_PARAMETER;
2209       goto Done;
2210     }
2211   } else {
2212     Item = ChkPck.VarList;
2213     if (Item) {
2214       ArgVar = (UINTN) StrToUIntegerBase (Item->VarStr, 16, &Status);
2215       if (EFI_ERROR (Status)) {
2216         PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_INVALID_ARG), HiiEnvHandle, L"dh", Item->VarStr);
2217         Status = EFI_INVALID_PARAMETER;
2218         goto Done;
2219       }
2220
2221       Arg = Item->VarStr;
2222     }
2223   }
2224   //
2225   //
2226   // Load handle & protocol info tables
2227   //
2228   SEnvLoadHandleTable ();
2229   SEnvLoadHandleProtocolInfo (NULL);
2230
2231   if (Arg) {
2232     if (ByProtocol) {
2233       AcquireLock (&SEnvGuidLock);
2234       Prot = SEnvGetProtByStr (Arg);
2235       ReleaseLock (&SEnvGuidLock);
2236
2237       if (Prot) {
2238         //
2239         // Dump the handles on this protocol
2240         //
2241         PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_NHANDLE_DUMP), HiiEnvHandle, Prot->IdString);
2242         for (Index = 0; Index < Prot->NoHandles; Index++) {
2243           Status = SEnvDHProt (Verbose, DriverModel, 0, Prot->Handles[Index], Language);
2244           if (EFI_ERROR (Status)) {
2245             goto Done;
2246           }
2247
2248         }
2249       } else {
2250         PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_PROTOCOL_NOT_FOUND), HiiEnvHandle, L"dh", Arg);
2251       }
2252     } else {
2253       //
2254       // Dump 1 handle
2255       //
2256       Index = SEnvHandleNoFromUINT (ArgVar) - 1;
2257       if (Index > SEnvNoHandles) {
2258         PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_HANDLE_OUT_OF_RANGE), HiiEnvHandle, L"dh", Arg);
2259         Status = EFI_INVALID_PARAMETER;
2260         goto Done;
2261       } else {
2262         if (DriverModel) {
2263           Status = SEnvDHProt (
2264                     Verbose,
2265                     DriverModel,
2266                     Index + 1,
2267                     SEnvHandles[Index],
2268                     Language
2269                     );
2270
2271         } else {
2272           Status = SEnvDHProt (
2273                     TRUE,
2274                     DriverModel,
2275                     Index + 1,
2276                     SEnvHandles[Index],
2277                     Language
2278                     );
2279         }
2280
2281         if (EFI_ERROR (Status)) {
2282           goto Done;
2283         }
2284       }
2285     }
2286   } else {
2287     //
2288     // Dump all handles
2289     //
2290     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_HANDLE_DUMP), HiiEnvHandle);
2291     for (Index = 0; Index < SEnvNoHandles; Index++) {
2292       Status = SEnvDHProt (
2293                 Verbose,
2294                 DriverModel,
2295                 Index + 1,
2296                 SEnvHandles[Index],
2297                 Language
2298                 );
2299       if (EFI_ERROR (Status)) {
2300         goto Done;
2301       }
2302     }
2303   }
2304
2305   Status = EFI_SUCCESS;
2306
2307 Done:
2308   if (Language != NULL) {
2309     FreePool (Language);
2310   }
2311
2312   SEnvFreeHandleTable ();
2313   LibCheckVarFreeVarList (&ChkPck);
2314   return Status;
2315 }
2316
2317 EFI_STATUS
2318 SEnvDeviceTree (
2319   IN EFI_HANDLE       ControllerHandle,
2320   IN UINTN            Level,
2321   IN BOOLEAN          RootOnly,
2322   IN BOOLEAN          BestName,
2323   IN CHAR8            *Language
2324   )
2325 /*++
2326
2327 Routine Description:
2328
2329 Arguments:
2330
2331   ControllerHandle - The Controller handle
2332   Level            - The level
2333   RootOnly         - Root only
2334   BestName         - The best Name
2335   Language         - Language
2336
2337 Returns:
2338
2339 --*/
2340 {
2341   EFI_STATUS                  Status;
2342   EFI_LOADED_IMAGE_PROTOCOL   *Image;
2343   EFI_DRIVER_BINDING_PROTOCOL *DriverBinding;
2344   UINT32                      ControllerHandleIndex;
2345   UINTN                       HandleCount;
2346   EFI_HANDLE                  *HandleBuffer;
2347   UINT32                      *HandleType;
2348   UINTN                       HandleIndex;
2349   UINTN                       ChildIndex;
2350   EFI_DEVICE_PATH_PROTOCOL    *DevicePath;
2351   UINTN                       ChildHandleCount;
2352   EFI_HANDLE                  *ChildHandleBuffer;
2353   UINT32                      *ChildHandleType;
2354   UINTN                       Index;
2355   BOOLEAN                     Root;
2356   EFI_STATUS                  ConfigurationStatus;
2357   EFI_STATUS                  DiagnosticsStatus;
2358   CHAR16                      *DeviceName;
2359
2360   Status = BS->OpenProtocol (
2361                 ControllerHandle,
2362                 &gEfiDriverBindingProtocolGuid,
2363                 (VOID **) &DriverBinding,
2364                 NULL,
2365                 NULL,
2366                 EFI_OPEN_PROTOCOL_GET_PROTOCOL
2367                 );
2368   if (!EFI_ERROR (Status)) {
2369     return EFI_SUCCESS;
2370   }
2371
2372   Status = BS->OpenProtocol (
2373                 ControllerHandle,
2374                 &gEfiLoadedImageProtocolGuid,
2375                 (VOID **) &Image,
2376                 NULL,
2377                 NULL,
2378                 EFI_OPEN_PROTOCOL_GET_PROTOCOL
2379                 );
2380   if (!EFI_ERROR (Status)) {
2381     return EFI_SUCCESS;
2382   }
2383
2384   Status = LibScanHandleDatabase (
2385             NULL,
2386             NULL,
2387             ControllerHandle,
2388             &ControllerHandleIndex,
2389             &HandleCount,
2390             &HandleBuffer,
2391             &HandleType
2392             );
2393   if (EFI_ERROR (Status)) {
2394     return EFI_SUCCESS;
2395   }
2396
2397   if (RootOnly) {
2398     Root = TRUE;
2399     for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++) {
2400       if (HandleType[HandleIndex] & EFI_HANDLE_TYPE_PARENT_HANDLE) {
2401         Root = FALSE;
2402       }
2403     }
2404
2405     Status = BS->OpenProtocol (
2406                   ControllerHandle,
2407                   &gEfiDevicePathProtocolGuid,
2408                   (VOID **) &DevicePath,
2409                   NULL,
2410                   NULL,
2411                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
2412                   );
2413     if (EFI_ERROR (Status)) {
2414       Root = FALSE;
2415     }
2416
2417     if (!Root) {
2418       return EFI_SUCCESS;
2419     }
2420   }
2421   //
2422   // Display the handle specified by ControllerHandle
2423   //
2424   for (Index = 0; Index < Level; Index++) {
2425     Print (L"  ");
2426   }
2427
2428   PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_CTRL), HiiEnvHandle, SEnvHandleToNumber (ControllerHandle));
2429
2430   Status = SEnvGetDeviceName (
2431             ControllerHandle,
2432             BestName,
2433             TRUE,
2434             Language,
2435             &DeviceName,
2436             &ConfigurationStatus,
2437             &DiagnosticsStatus,
2438             FALSE,
2439             0
2440             );
2441   if (DeviceName != NULL) {
2442     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_ONE_VAR_S), HiiEnvHandle, DeviceName);
2443   } else {
2444     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_UNKNOWN_2), HiiEnvHandle);
2445   }
2446   //
2447   // Print the list of drivers that are managing this controller
2448   //
2449   for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++) {
2450     if (HandleType[HandleIndex] & EFI_HANDLE_TYPE_DRIVER_BINDING_HANDLE &&
2451         HandleType[HandleIndex] & EFI_HANDLE_TYPE_DEVICE_DRIVER
2452         ) {
2453
2454       DriverBinding = NULL;
2455       Status = BS->OpenProtocol (
2456                     HandleBuffer[HandleIndex],
2457                     &gEfiDriverBindingProtocolGuid,
2458                     (VOID **) &DriverBinding,
2459                     NULL,
2460                     NULL,
2461                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
2462                     );
2463
2464       Status = LibScanHandleDatabase (
2465                 HandleBuffer[HandleIndex],
2466                 NULL,
2467                 ControllerHandle,
2468                 &ControllerHandleIndex,
2469                 &ChildHandleCount,
2470                 &ChildHandleBuffer,
2471                 &ChildHandleType
2472                 );
2473
2474       if (!EFI_ERROR (Status)) {
2475         for (ChildIndex = 0; ChildIndex < ChildHandleCount; ChildIndex++) {
2476           if (ChildHandleType[ChildIndex] & EFI_HANDLE_TYPE_CHILD_HANDLE &&
2477               ChildHandleType[ChildIndex] & EFI_HANDLE_TYPE_DEVICE_HANDLE
2478               ) {
2479
2480             Status = SEnvDeviceTree (
2481                       ChildHandleBuffer[ChildIndex],
2482                       Level + 1,
2483                       FALSE,
2484                       BestName,
2485                       Language
2486                       );
2487             if (EFI_ERROR (Status)) {
2488               return Status;
2489             }
2490           }
2491         }
2492
2493         FreePool (ChildHandleBuffer);
2494         FreePool (ChildHandleType);
2495       }
2496     }
2497   }
2498
2499   FreePool (HandleBuffer);
2500   FreePool (HandleType);
2501
2502   return EFI_SUCCESS;
2503 }
2504
2505 EFI_STATUS
2506 SEnvCmdDriverConfigurationProcessActionRequired (
2507   EFI_HANDLE                                DriverImageHandle,
2508   EFI_HANDLE                                ControllerHandle,
2509   EFI_HANDLE                                ChildHandle,
2510   EFI_DRIVER_CONFIGURATION_ACTION_REQUIRED  ActionRequired
2511   )
2512
2513 {
2514   CHAR16      ReturnStr[2];
2515   EFI_HANDLE  ContextOverride[2];
2516
2517   switch (ActionRequired) {
2518   case EfiDriverConfigurationActionNone:
2519     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_NONE), HiiEnvHandle);
2520     break;
2521
2522   case EfiDriverConfigurationActionStopController:
2523     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_STOP_CONTROLLER), HiiEnvHandle);
2524     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_ENTER_STOP_CONTROL), HiiEnvHandle);
2525     Input (L"", ReturnStr, sizeof (ReturnStr) / sizeof (CHAR16));
2526     Print (L"\n");
2527     BS->DisconnectController (ControllerHandle, DriverImageHandle, ChildHandle);
2528     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_CONTROLLER_STOPPED), HiiEnvHandle);
2529     break;
2530
2531   case EfiDriverConfigurationActionRestartController:
2532     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_RESTART_CONTROLLER), HiiEnvHandle);
2533     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_ENTER_RESTART_CONTROLLER), HiiEnvHandle);
2534     Input (L"", ReturnStr, sizeof (ReturnStr) / sizeof (CHAR16));
2535     Print (L"\n");
2536     BS->DisconnectController (ControllerHandle, DriverImageHandle, ChildHandle);
2537     ContextOverride[0]  = DriverImageHandle;
2538     ContextOverride[1]  = NULL;
2539     BS->ConnectController (ControllerHandle, ContextOverride, NULL, TRUE);
2540     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_CONTROLLER_RESTARTED), HiiEnvHandle);
2541     break;
2542
2543   case EfiDriverConfigurationActionRestartPlatform:
2544     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_RESTART_PLATFORM), HiiEnvHandle);
2545     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_ENTER_RESTART_PLATFORM), HiiEnvHandle);
2546     Input (L"", ReturnStr, sizeof (ReturnStr) / sizeof (CHAR16));
2547     RT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL);
2548     break;
2549
2550   default:
2551     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_UNKNOWN_3), HiiEnvHandle);
2552     break;
2553   }
2554
2555   return EFI_SUCCESS;
2556 }
2557
2558 EFI_STATUS
2559 SEnvCmdDriverRunDiagnostics (
2560   EFI_DRIVER_DIAGNOSTICS_PROTOCOL   *DriverDiagnostics,
2561   EFI_HANDLE                        ControllerHandle,
2562   EFI_HANDLE                        ChildHandle,
2563   EFI_DRIVER_DIAGNOSTIC_TYPE        DiagnosticType,
2564   CHAR8                             *Language
2565   )
2566
2567 {
2568   EFI_STATUS  Status;
2569   EFI_GUID    *ErrorType;
2570   UINTN       BufferSize;
2571   CHAR16      *Buffer;
2572
2573   ErrorType   = NULL;
2574   BufferSize  = 0;
2575   Buffer      = NULL;
2576   Status = DriverDiagnostics->RunDiagnostics (
2577                                 DriverDiagnostics,
2578                                 ControllerHandle,
2579                                 ChildHandle,
2580                                 DiagnosticType,
2581                                 Language,
2582                                 &ErrorType,
2583                                 &BufferSize,
2584                                 &Buffer
2585                                 );
2586
2587   if (!EFI_ERROR (Status)) {
2588     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_HPASSED), HiiEnvHandle);
2589   } else {
2590     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_HFAILED), HiiEnvHandle, Status);
2591   }
2592
2593   if (ErrorType != NULL) {
2594     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_ERRORTYPE), HiiEnvHandle, ErrorType);
2595   }
2596
2597   if (BufferSize > 0) {
2598     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_BUFFERSIZE), HiiEnvHandle, BufferSize);
2599     PrintToken (STRING_TOKEN (STR_SHELLENV_PROTID_BUFFER_ONE_VAR), HiiEnvHandle, Buffer);
2600     DumpHex (2, 0, BufferSize, Buffer);
2601     FreePool (Buffer);
2602   }
2603
2604   return EFI_SUCCESS;
2605 }
2606
2607 extern EFI_LIST_ENTRY SEnvMap;
2608 extern EFI_LIST_ENTRY SEnvEnv;
2609 extern EFI_LIST_ENTRY SEnvAlias;
2610
2611 EFI_STATUS
2612 EFIAPI
2613 SEnvLoadDefaults (
2614   IN EFI_HANDLE           Image,
2615   IN EFI_SYSTEM_TABLE     *SystemTable
2616   )
2617 /*++
2618
2619 Routine Description:
2620
2621 Arguments:
2622
2623   Image       - The image handle
2624   SystemTable - The system table
2625
2626 Returns:
2627
2628 --*/
2629 {
2630   //
2631   // These commands are guaranteed to be internal commands
2632   //
2633   SEnvExecute (Image, L"@alias copy cp", TRUE);
2634   SEnvExecute (Image, L"@alias del rm", TRUE);
2635   SEnvExecute (Image, L"@alias dir ls", TRUE);
2636   SEnvExecute (Image, L"@alias md mkdir", TRUE);
2637   SEnvExecute (Image, L"@alias rd rm", TRUE);
2638   SEnvExecute (Image, L"@set -v efishellmode "EFI_SHELL_ENHANCED_MODE_VER, TRUE);
2639   SEnvExecute (Image, L"@alias cr \"echo Current Running Mode: ^%efishellmode^%\"", TRUE);
2640
2641   return EFI_SUCCESS;
2642 }
2643
2644 VOID
2645 SEnvGetDevicePathList (
2646   EFI_LIST_ENTRY    *ListHead,
2647   EFI_GUID          *Protocol
2648   )
2649 /*++
2650
2651 Routine Description:
2652   Get current device paths by specified protocol
2653
2654 Arguments:
2655
2656   ListHead - The list head
2657   Protocol - The protocol
2658
2659 Returns:
2660
2661 --*/
2662 {
2663   EFI_STATUS                Status;
2664
2665   DEVICEPATH_INFO           *DevicePathInfo;
2666
2667   UINTN                     Index;
2668   UINTN                     NoHandles;
2669   EFI_HANDLE                *Handles;
2670
2671   EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
2672   UINTN                     DevPathSize;
2673
2674   //
2675   // Remove previous device path info
2676   //
2677   while (!IsListEmpty (ListHead)) {
2678     DevicePathInfo = (DEVICEPATH_INFO *) (CR (
2679                                             ListHead->Flink,
2680                                             DEVICEPATH_INFO,
2681                                             Link,
2682                                             DEVICEPATH_INFO_SIGNATURE
2683                                             ));
2684     FreePool (DevicePathInfo->DevicePath);
2685     RemoveEntryList (&DevicePathInfo->Link);
2686     FreePool (DevicePathInfo);
2687   }
2688   //
2689   // Establish current device path info list
2690   //
2691   Status = LibLocateHandle (
2692             ByProtocol,
2693             Protocol,
2694             NULL,
2695             &NoHandles,
2696             &Handles
2697             );
2698
2699   if (NoHandles) {
2700     for (Index = 0; Index < NoHandles; Index++) {
2701       DevicePath = DevicePathFromHandle (Handles[Index]);
2702       if (!DevicePath) {
2703         continue;
2704       }
2705
2706       DevPathSize = DevicePathSize (DevicePath);
2707
2708       //
2709       // Copy device path info to the device path list
2710       //
2711       DevicePathInfo              = AllocateZeroPool (sizeof (DEVICEPATH_INFO));
2712       DevicePathInfo->DevicePath  = AllocateZeroPool (DevPathSize);
2713       CopyMem (DevicePathInfo->DevicePath, DevicePath, DevPathSize);
2714       DevicePathInfo->Found     = FALSE;
2715       DevicePathInfo->Signature = DEVICEPATH_INFO_SIGNATURE;
2716       InsertTailList (ListHead, &DevicePathInfo->Link);
2717     }
2718   }
2719 }
2720
2721 BOOLEAN
2722 SEnvCompareDevicePathList (
2723   EFI_LIST_ENTRY    *ListHead1,
2724   EFI_LIST_ENTRY    *ListHead2
2725   )
2726 /*++
2727
2728 Routine Description:
2729   Compare devicepath list
2730
2731 Arguments:
2732
2733   ListHead1 - The first list
2734   ListHead2 - Thes second list
2735
2736 Returns:
2737
2738 --*/
2739 {
2740   EFI_LIST_ENTRY  *Link1;
2741   EFI_LIST_ENTRY  *Link2;
2742
2743   DEVICEPATH_INFO *DevicePathInfo1;
2744   DEVICEPATH_INFO *DevicePathInfo2;
2745
2746   if (IsListEmpty (ListHead1) || IsListEmpty (ListHead2)) {
2747     return FALSE;
2748   }
2749   //
2750   // Compare two device path lists
2751   //
2752   for (Link1 = ListHead1->Flink; Link1 != ListHead1; Link1 = Link1->Flink) {
2753     DevicePathInfo1 = CR (Link1, DEVICEPATH_INFO, Link, DEVICEPATH_INFO_SIGNATURE);
2754     for (Link2 = ListHead2->Flink; Link2 != ListHead2; Link2 = Link2->Flink) {
2755       DevicePathInfo2 = CR (Link2, DEVICEPATH_INFO, Link, DEVICEPATH_INFO_SIGNATURE);
2756       if (DevicePathCompare (DevicePathInfo1->DevicePath, DevicePathInfo2->DevicePath) == 0) {
2757         DevicePathInfo1->Found  = TRUE;
2758         DevicePathInfo2->Found  = TRUE;
2759         break;
2760       }
2761     }
2762
2763     if (!DevicePathInfo1->Found) {
2764       //
2765       // Devicepath node in devicepath1 is not in devicepath2 list,
2766       // don't need to continue comparing
2767       //
2768       return FALSE;
2769     }
2770   }
2771   //
2772   // All devicepath nodes in devicepath1 list are in devicepath2 list,
2773   // so we just need to find if there are new device path in devicepath2 list
2774   //
2775   for (Link2 = ListHead2->Flink; Link2 != ListHead2; Link2 = Link2->Flink) {
2776     DevicePathInfo2 = CR (
2777                         Link2,
2778                         DEVICEPATH_INFO,
2779                         Link,
2780                         DEVICEPATH_INFO_SIGNATURE
2781                         );
2782     if (!DevicePathInfo2->Found) {
2783       return FALSE;
2784     }
2785   }
2786
2787   return TRUE;
2788 }
2789 //
2790 // functions to enumerate protocol database
2791 //
2792 EFI_LIST_ENTRY  *ProtocolInfoEnum;
2793
2794 VOID
2795 SEnvInitProtocolInfoEnumerator (
2796   VOID
2797   )
2798 {
2799   SEnvLoadHandleTable ();
2800   SEnvLoadHandleProtocolInfo (NULL);
2801   ProtocolInfoEnum = &SEnvProtocolInfo;
2802 }
2803
2804 EFI_STATUS
2805 SEnvNextProtocolInfo (
2806   IN OUT   PROTOCOL_INFO            **ProtocolInfo
2807   )
2808 {
2809   ProtocolInfoEnum = ProtocolInfoEnum->Flink;
2810   if (ProtocolInfoEnum == &SEnvProtocolInfo) {
2811     *ProtocolInfo = NULL;
2812     return EFI_SUCCESS;
2813   }
2814
2815   if (ProtocolInfoEnum != &SEnvProtocolInfo) {
2816     *ProtocolInfo = CR (ProtocolInfoEnum, PROTOCOL_INFO, Link, PROTOCOL_INFO_SIGNATURE);
2817   }
2818
2819   return EFI_SUCCESS;
2820 }
2821
2822 EFI_STATUS
2823 SEnvSkipProtocolInfo (
2824   IN UINTN                  SkipNum
2825   )
2826 {
2827
2828   return EFI_SUCCESS;
2829 }
2830
2831 VOID
2832 SEnvResetProtocolInfoEnumerator (
2833   VOID
2834   )
2835 {
2836   ProtocolInfoEnum = &SEnvProtocolInfo;
2837 }
2838
2839 VOID
2840 SEnvCloseProtocolInfoEnumerator (
2841   VOID
2842   )
2843 {
2844   SEnvFreeHandleTable ();
2845   ProtocolInfoEnum = NULL;
2846 }
2847
2848 EFI_STATUS
2849 EFIAPI
2850 SEnvCmdDHGetLineHelp (
2851   IN CHAR16                   **Str
2852   )
2853 /*++
2854
2855 Routine Description:
2856
2857   Get this command's line help
2858
2859 Arguments:
2860
2861   Str - The line help
2862
2863 Returns:
2864
2865   EFI_SUCCESS   - Success
2866
2867 --*/
2868 {
2869   return SEnvCmdGetStringByToken (STRING_TOKEN (STR_SHELLENV_DH_LINE_HELP), Str);
2870 }