SHEL19
[efi/shell/.git] / shellenv / dprot.c
1 /*++
2
3 Copyright (c) 2005 - 2008, 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   dprot.c
15
16 Abstract:
17
18   Shell environment - dump protocol functions for the "dh" command
19
20 Revision History
21
22 --*/
23
24 #include "shelle.h"
25 #include "shellenvguid.h"
26 #include "acpi.h"
27
28 STATIC CHAR16 *SEnvDP_IlleagalStr[] = { L"Illegal" };
29
30 STATIC CHAR16 *SEnvDP_HardwareStr[] = {
31   L"Illegal",
32   L"PCI",
33   L"PCMCIA",
34   L"Memory Mapped",
35   L"Vendor-Defined",
36   L"Controller"
37 };
38
39 STATIC CHAR16 *SEnvDP_ACPI_Str[] = { L"Illegal", L"Acpi", L"AcpiEx", L"AcpiAdr" };
40
41 STATIC CHAR16 *SEnvDP_MessageStr[] = {
42   L"Illegal",
43   L"ATAPI",
44   L"SCSI",
45   L"Fibre Channel",
46   L"1394",
47   L"USB",
48   L"I2O",
49   L"Illegal",
50   L"Illegal",
51   L"InfiniBand",
52   L"Vendor-Defined",
53   L"MAC",
54   L"IPv4",
55   L"IPv6",
56   L"UART",
57   L"USB Class",
58   L"USB WWID",
59   L"Device Logical Unit",
60   L"SATA",
61   L"iSCSI"
62 };
63
64 STATIC CHAR16 *SEnvDP_MediaStr[] = {
65   L"Illegal",
66   L"Hard Drive",
67   L"CD-ROM",
68   L"Vender-Defined",
69   L"File Path",
70   L"Media Protocol",
71   L"PIWG FV",
72   L"PIWG Firmware File",
73   L"Relative Offset Range",
74 };
75
76 STATIC CHAR16 *SEnvDP_BBS_Str[] = { L"Illegal", L"BIOS Boot Spec" };
77
78 struct DevicePathTypes {
79   UINT8   Type;
80   UINT8   MaxSubType;
81   CHAR16  *TypeString;
82   CHAR16  **SubTypeStr;
83   VOID (*Function) (EFI_DEVICE_PATH_PROTOCOL *);
84 };
85
86 VOID
87 SEnvHardwareDevicePathEntry (
88   IN EFI_DEVICE_PATH_PROTOCOL  *DevicePath
89   )
90 /*++
91
92 Routine Description:
93
94 Arguments:
95
96   DevicePath - The device path
97
98 Returns:
99
100 --*/
101 {
102   PCI_DEVICE_PATH         *PciDevicePath;
103   PCCARD_DEVICE_PATH      *PcCardDevicePath;
104   MEMMAP_DEVICE_PATH      *MemMapDevicePath;
105   CONTROLLER_DEVICE_PATH  *ControllerDevicePath;
106   VENDOR_DEVICE_PATH      *VendorDevicePath;
107
108   if (DevicePathType (DevicePath) != HW_PCI_DP) {
109     return ;
110   }
111   //
112   // Process hardware device path entry
113   //
114   switch (DevicePathSubType (DevicePath)) {
115   case HW_PCI_DP:
116     PciDevicePath = (PCI_DEVICE_PATH *) DevicePath;
117     PrintToken (
118       STRING_TOKEN (STR_SHELLENV_DPROT_FUNCTION_DEVICE),
119       HiiEnvHandle,
120       PciDevicePath->Function,
121       PciDevicePath->Device
122       );
123     break;
124
125   case HW_PCCARD_DP:
126     PcCardDevicePath = (PCCARD_DEVICE_PATH *) DevicePath;
127     PrintToken (
128       STRING_TOKEN (STR_SHELLENV_DPROT_FUNCTION_NUMBER),
129       HiiEnvHandle,
130       PcCardDevicePath->FunctionNumber
131       );
132     break;
133
134   case HW_MEMMAP_DP:
135     MemMapDevicePath = (MEMMAP_DEVICE_PATH *) DevicePath;
136     PrintToken (
137       STRING_TOKEN (STR_SHELLENV_DPROT_MEMORY_TYPE),
138       HiiEnvHandle,
139       MemMapDevicePath->MemoryType,
140       MemMapDevicePath->StartingAddress,
141       MemMapDevicePath->EndingAddress
142       );
143     break;
144
145   case HW_CONTROLLER_DP:
146     ControllerDevicePath = (CONTROLLER_DEVICE_PATH *) DevicePath;
147     PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_CONTROLLER_NUMBER), HiiEnvHandle, ControllerDevicePath->Controller);
148     break;
149
150   case HW_VENDOR_DP:
151     VendorDevicePath = (VENDOR_DEVICE_PATH *) DevicePath;
152     PrintToken (
153       STRING_TOKEN (STR_SHELLENV_DPROT_GUID),
154       HiiEnvHandle,
155       &VendorDevicePath->Guid
156       );
157     if (DevicePathNodeLength (DevicePath) > sizeof (VENDOR_DEVICE_PATH)) {
158       Print (L"\n");
159       DumpHex (
160         7,
161         0,
162         DevicePathNodeLength (DevicePath) - sizeof (VENDOR_DEVICE_PATH),
163         VendorDevicePath + 1
164         );
165     }
166     break;
167   }
168   //
169   // End processing
170   //
171 }
172
173 VOID
174 SEnvAcpiDevicePathEntry (
175   IN EFI_DEVICE_PATH_PROTOCOL      *DevicePath
176   )
177 /*++
178
179 Routine Description:
180
181 Arguments:
182
183   DevicePath - The device path
184
185 Returns:
186
187 --*/
188 {
189   ACPI_HID_DEVICE_PATH                   *AcpiDevicePath;
190   ACPI_EXTENDED_HID_DEVICE_PATH_WITH_STR *AcpiExDevicepath;
191   ACPI_ADR_DEVICE_PATH                   *AcpiAdrDevicePath;
192   UINT16                                 Index;
193   UINT16                                 Length;
194   UINT16                                 AdditionalAdrCount;
195   CHAR8                                  *HIDString;
196   CHAR8                                  *UIDString;
197   CHAR8                                  *CIDString;
198   CHAR8                                  NullString[5];
199
200   if (DevicePathType (DevicePath) != ACPI_DEVICE_PATH) {
201     return ;
202   }
203   //
204   // Process ACPI device path entry
205   //
206   switch (DevicePathSubType (DevicePath)) {
207   case ACPI_DP:
208     AcpiDevicePath = (ACPI_HID_DEVICE_PATH *) DevicePath;
209     if ((AcpiDevicePath->HID & PNP_EISA_ID_MASK) == PNP_EISA_ID_CONST) {
210       PrintToken (
211         STRING_TOKEN (STR_SHELLENV_DPROT_HIDPNP_UID),
212         HiiEnvHandle,
213         EISA_ID_TO_NUM (AcpiDevicePath->HID),
214         AcpiDevicePath->UID
215         );
216     } else {
217        PrintToken (
218         STRING_TOKEN (STR_SHELLENV_DPROT_HID_UID),
219         HiiEnvHandle,
220         AcpiDevicePath->HID,
221         AcpiDevicePath->UID
222         );
223     }
224     break;
225   case ACPI_EXTENDED_DP:
226     AcpiExDevicepath = (ACPI_EXTENDED_HID_DEVICE_PATH_WITH_STR *) DevicePath;
227     HIDString        = AcpiExDevicepath->HidUidCidStr;
228     UIDString        = NextStrA (HIDString);
229     CIDString        = NextStrA (UIDString);
230     CopyMem (NullString, "NULL", sizeof (NullString));
231     if (*HIDString == '\0') {
232       HIDString = NullString;
233     }
234     if (*UIDString == '\0') {
235       UIDString = NullString;
236     }
237     if (*CIDString == '\0') {
238       CIDString = NullString;
239     }
240     if ((AcpiExDevicepath->HID & PNP_EISA_ID_MASK) == PNP_EISA_ID_CONST) {
241       if ((AcpiExDevicepath->CID & PNP_EISA_ID_MASK) == PNP_EISA_ID_CONST) {
242         PrintToken (
243           STRING_TOKEN (STR_SHELLENV_DPROT_HIDPNP_CIDPNP_UID),
244           HiiEnvHandle,
245           EISA_ID_TO_NUM (AcpiExDevicepath->HID),
246           EISA_ID_TO_NUM (AcpiExDevicepath->CID),
247           AcpiExDevicepath->UID,
248           HIDString,
249           CIDString,
250           UIDString
251           );
252       } else {
253         PrintToken (
254           STRING_TOKEN (STR_SHELLENV_DPROT_HIDPNP_CID_UID),
255           HiiEnvHandle,
256           EISA_ID_TO_NUM (AcpiExDevicepath->HID),
257           AcpiExDevicepath->CID,
258           AcpiExDevicepath->UID,
259           HIDString,
260           CIDString,
261           UIDString
262           );
263       }
264     } else {
265       if ((AcpiExDevicepath->CID & PNP_EISA_ID_MASK) == PNP_EISA_ID_CONST) {
266         PrintToken (
267           STRING_TOKEN (STR_SHELLENV_DPROT_HID_CIDPNP_UID),
268           HiiEnvHandle,
269           AcpiExDevicepath->HID,
270           EISA_ID_TO_NUM (AcpiExDevicepath->CID),
271           AcpiExDevicepath->UID,
272           HIDString,
273           CIDString,
274           UIDString
275           );
276       } else {
277         PrintToken (
278           STRING_TOKEN (STR_SHELLENV_DPROT_HID_CID_UID),
279           HiiEnvHandle,
280           AcpiExDevicepath->HID,
281           AcpiExDevicepath->CID,
282           AcpiExDevicepath->UID,
283           HIDString,
284           CIDString,
285           UIDString
286           );
287       }
288     }
289     break;
290   case ACPI_ADR_DP:
291     AcpiAdrDevicePath  = (ACPI_ADR_DEVICE_PATH *) DevicePath;
292     Length             = DevicePathNodeLength (DevicePath);
293     AdditionalAdrCount = (Length - 8) / 4;
294
295     PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_ADR), HiiEnvHandle);
296     Print (L"%hx", AcpiAdrDevicePath->ADR);
297     for (Index = 0; Index < AdditionalAdrCount; Index++) {
298       Print (L",%hx", *(UINT32 *) ((UINT8 *) AcpiAdrDevicePath + 8 + Index * 4));
299     }
300     break;
301   default:
302     break;
303   }
304 }
305
306 VOID
307 SEnvMessagingDevicePathEntry (
308   IN EFI_DEVICE_PATH_PROTOCOL      *DevicePath
309   )
310 /*++
311
312 Routine Description:
313
314 Arguments:
315
316   DevicePath - The device path
317
318 Returns:
319
320 --*/
321 {
322   ATAPI_DEVICE_PATH         *AtapiDevicePath;
323   SCSI_DEVICE_PATH          *ScsiDevicePath;
324   FIBRECHANNEL_DEVICE_PATH  *FibreChannelDevicePath;
325   F1394_DEVICE_PATH         *F1394DevicePath;
326   USB_DEVICE_PATH           *UsbDevicePath;
327   USB_CLASS_DEVICE_PATH     *UsbClassDevicePath;
328   I2O_DEVICE_PATH           *I2ODevicePath;
329   MAC_ADDR_DEVICE_PATH      *MacAddrDevicePath;
330   IPv4_DEVICE_PATH          *IPv4DevicePath;
331   IPv6_DEVICE_PATH          *IPv6DevicePath;
332   INFINIBAND_DEVICE_PATH    *InfinibandDevicePath;
333   UART_DEVICE_PATH          *UartDevicePath;
334   VENDOR_DEVICE_PATH        *VendorDevicePath;
335
336   UINTN                     HwAddressSize;
337   UINTN                     Index;
338   CHAR8                     Parity;
339
340   if (DevicePathType (DevicePath) != MESSAGING_DEVICE_PATH) {
341     return ;
342   }
343   //
344   // Process messaging device path entry
345   //
346   switch (DevicePathSubType (DevicePath)) {
347   case MSG_ATAPI_DP:
348     AtapiDevicePath = (ATAPI_DEVICE_PATH *) DevicePath;
349     PrintToken (
350       STRING_TOKEN (STR_SHELLENV_DPROT_ATAPI),
351       HiiEnvHandle,
352       AtapiDevicePath->PrimarySecondary ? L"Secondary" : L"Primary",
353       AtapiDevicePath->SlaveMaster ? L"Slave" : L"Master",
354       AtapiDevicePath->Lun
355       );
356     break;
357
358   case MSG_SCSI_DP:
359     ScsiDevicePath = (SCSI_DEVICE_PATH *) DevicePath;
360     PrintToken (
361       STRING_TOKEN (STR_SHELLENV_DPROT_PUN_LUN),
362       HiiEnvHandle,
363       ScsiDevicePath->Pun,
364       ScsiDevicePath->Lun
365       );
366     break;
367
368   case MSG_FIBRECHANNEL_DP:
369     FibreChannelDevicePath = (FIBRECHANNEL_DEVICE_PATH *) DevicePath;
370     PrintToken (
371       STRING_TOKEN (STR_SHELLENV_DPROT_FIBRE_CHANNEL),
372       HiiEnvHandle,
373       FibreChannelDevicePath->WWN,
374       FibreChannelDevicePath->Lun
375       );
376     break;
377
378   case MSG_1394_DP:
379     F1394DevicePath = (F1394_DEVICE_PATH *) DevicePath;
380     PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_GUID_2), HiiEnvHandle, F1394DevicePath->Guid);
381     break;
382
383   case MSG_USB_DP:
384     UsbDevicePath = (USB_DEVICE_PATH *) DevicePath;
385     PrintToken (
386       STRING_TOKEN (STR_SHELLENV_DPROT_USB),
387       HiiEnvHandle,
388       UsbDevicePath->ParentPortNumber,
389       UsbDevicePath->InterfaceNumber
390       );
391     break;
392
393   case MSG_USB_CLASS_DP:
394     UsbClassDevicePath = (USB_CLASS_DEVICE_PATH *) DevicePath;
395     PrintToken (
396       STRING_TOKEN (STR_SHELLENV_DPROT_USB_CLASS),
397       HiiEnvHandle,
398       UsbClassDevicePath->VendorId,
399       UsbClassDevicePath->ProductId
400       );
401     PrintToken (
402       STRING_TOKEN (STR_SHELLENV_DPROT_DEVICE),
403       HiiEnvHandle,
404       UsbClassDevicePath->DeviceClass,
405       UsbClassDevicePath->DeviceSubClass,
406       UsbClassDevicePath->DeviceProtocol
407       );
408     break;
409
410   case MSG_I2O_DP:
411     I2ODevicePath = (I2O_DEVICE_PATH *) DevicePath;
412     PrintToken (
413       STRING_TOKEN (STR_SHELLENV_DPROT_I20),
414       HiiEnvHandle,
415       I2ODevicePath->Tid
416       );
417     break;
418
419   case MSG_MAC_ADDR_DP:
420     MacAddrDevicePath = (MAC_ADDR_DEVICE_PATH *) DevicePath;
421     HwAddressSize     = sizeof (EFI_MAC_ADDRESS);
422     if (MacAddrDevicePath->IfType == 0x01 || MacAddrDevicePath->IfType == 0x00) {
423       HwAddressSize = 6;
424     }
425
426     PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_MAC), HiiEnvHandle);
427     for (Index = 0; Index < HwAddressSize; Index++) {
428       PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_ONE_VAR_X), HiiEnvHandle, MacAddrDevicePath->MacAddress.Addr[Index]);
429     }
430
431     Print (L")");
432     break;
433
434   case MSG_IPv4_DP:
435     IPv4DevicePath = (IPv4_DEVICE_PATH *) DevicePath;
436     PrintToken (
437       STRING_TOKEN (STR_SHELLENV_DPROT_LOCAL),
438       HiiEnvHandle,
439       IPv4DevicePath->LocalIpAddress.Addr[0],
440       IPv4DevicePath->LocalIpAddress.Addr[1],
441       IPv4DevicePath->LocalIpAddress.Addr[2],
442       IPv4DevicePath->LocalIpAddress.Addr[3],
443       IPv4DevicePath->LocalPort
444       );
445     PrintToken (
446       STRING_TOKEN (STR_SHELLENV_DPROT_REMOVE_IP),
447       HiiEnvHandle,
448       IPv4DevicePath->RemoteIpAddress.Addr[0],
449       IPv4DevicePath->RemoteIpAddress.Addr[1],
450       IPv4DevicePath->RemoteIpAddress.Addr[2],
451       IPv4DevicePath->RemoteIpAddress.Addr[3],
452       IPv4DevicePath->RemotePort
453       );
454     PrintToken (
455       STRING_TOKEN (STR_SHELLENV_DPROT_PROTOCOL),
456       HiiEnvHandle,
457       IPv4DevicePath->Protocol
458       );
459     PrintToken (
460       STRING_TOKEN (STR_SHELLENV_DPROT_SOURCE),
461       HiiEnvHandle,
462       IPv4DevicePath->StaticIpAddress ? L"Static" : L"DHCP"
463       );
464     break;
465
466   case MSG_IPv6_DP:
467     IPv6DevicePath = (IPv6_DEVICE_PATH *) DevicePath;
468     PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_NOT_AVAIL), HiiEnvHandle);
469     break;
470
471   case MSG_INFINIBAND_DP:
472     InfinibandDevicePath = (INFINIBAND_DEVICE_PATH *) DevicePath;
473     PrintToken (
474       STRING_TOKEN (STR_SHELLENV_DPROT_MODE_GUID),
475       HiiEnvHandle,
476       InfinibandDevicePath->ServiceId,
477       InfinibandDevicePath->TargetPortId
478       );
479     PrintToken (
480       STRING_TOKEN (STR_SHELLENV_DPROT_DEVICE_ID),
481       HiiEnvHandle,
482       InfinibandDevicePath->DeviceId
483       );
484     break;
485
486   case MSG_UART_DP:
487     UartDevicePath = (UART_DEVICE_PATH *) DevicePath;
488     switch (UartDevicePath->Parity) {
489     case 0:
490       Parity = 'D';
491       break;
492
493     case 1:
494       Parity = 'N';
495       break;
496
497     case 2:
498       Parity = 'E';
499       break;
500
501     case 3:
502       Parity = 'O';
503       break;
504
505     case 4:
506       Parity = 'M';
507       break;
508
509     case 5:
510       Parity = 'S';
511       break;
512
513     default:
514       Parity = 'x';
515       break;
516     }
517
518     if (UartDevicePath->BaudRate == 0) {
519       PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_UART_DEFAULT), HiiEnvHandle, Parity);
520     } else {
521       PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_UART_D_C), HiiEnvHandle, UartDevicePath->BaudRate, Parity);
522     }
523
524     if (UartDevicePath->DataBits == 0) {
525       Print (L" D");
526     } else {
527       PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_ONE_VAR_D), HiiEnvHandle, UartDevicePath->DataBits);
528     }
529
530     switch (UartDevicePath->StopBits) {
531     case 0:
532       Print (L" D)");
533       break;
534
535     case 1:
536       Print (L" 1)");
537       break;
538
539     case 2:
540       Print (L" 1.5)");
541       break;
542
543     case 3:
544       Print (L" 2)");
545       break;
546
547     default:
548       Print (L" x)");
549       break;
550     }
551     break;
552
553   case MSG_VENDOR_DP:
554     VendorDevicePath = (VENDOR_DEVICE_PATH *) DevicePath;
555     PrintToken (
556       STRING_TOKEN (STR_SHELLENV_DPROT_GUID_G),
557       HiiEnvHandle,
558       &VendorDevicePath->Guid
559       );
560     if (DevicePathNodeLength (DevicePath) > sizeof (VENDOR_DEVICE_PATH)) {
561       Print (L"\n");
562       DumpHex (
563         7,
564         0,
565         DevicePathNodeLength (DevicePath) - sizeof (VENDOR_DEVICE_PATH),
566         VendorDevicePath + 1
567         );
568     }
569     break;
570   }
571   //
572   // End processing
573   //
574 }
575
576 VOID
577 SEnvMediaDevicePathEntry (
578   IN EFI_DEVICE_PATH_PROTOCOL  *DevicePath
579   )
580 /*++
581
582 Routine Description:
583
584 Arguments:
585
586   DevicePath - The device path
587
588 Returns:
589
590 --*/
591 {
592   HARDDRIVE_DEVICE_PATH       *HardDriveDevicePath;
593   CDROM_DEVICE_PATH           *CDDevicePath;
594   VENDOR_DEVICE_PATH          *VendorDevicePath;
595   FILEPATH_DEVICE_PATH        *FilePath;
596   MEDIA_PROTOCOL_DEVICE_PATH  *MediaProtocol;
597   MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH
598                               *Offset;
599
600   if (DevicePathType (DevicePath) != MEDIA_DEVICE_PATH) {
601     return ;
602   }
603   //
604   // Process media device path entry
605   //
606   switch (DevicePathSubType (DevicePath)) {
607   case MEDIA_HARDDRIVE_DP:
608     HardDriveDevicePath = (HARDDRIVE_DEVICE_PATH *) DevicePath;
609     PrintToken (
610       STRING_TOKEN (STR_SHELLENV_DPROT_PARTITION_START_SIZE),
611       HiiEnvHandle,
612       HardDriveDevicePath->PartitionNumber,
613       HardDriveDevicePath->PartitionStart,
614       HardDriveDevicePath->PartitionSize
615       );
616     break;
617
618   case MEDIA_CDROM_DP:
619     CDDevicePath = (CDROM_DEVICE_PATH *) DevicePath;
620     PrintToken (
621       STRING_TOKEN (STR_SHELLENV_DPROT_BOOTENTRY_START_SIZE),
622       HiiEnvHandle,
623       CDDevicePath->BootEntry,
624       CDDevicePath->PartitionStart,
625       CDDevicePath->PartitionSize
626       );
627     break;
628
629   case MEDIA_VENDOR_DP:
630     VendorDevicePath = (VENDOR_DEVICE_PATH *) DevicePath;
631     PrintToken (
632       STRING_TOKEN (STR_SHELLENV_DPROT_GUID_G),
633       HiiEnvHandle,
634       &VendorDevicePath->Guid
635       );
636     if (DevicePathNodeLength (DevicePath) > sizeof (VENDOR_DEVICE_PATH)) {
637       Print (L"\n");
638       DumpHex (
639         7,
640         0,
641         DevicePathNodeLength (DevicePath) - sizeof (VENDOR_DEVICE_PATH),
642         VendorDevicePath + 1
643         );
644     }
645     break;
646
647   case MEDIA_FILEPATH_DP:
648     FilePath = (FILEPATH_DEVICE_PATH *) DevicePath;
649     PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_FILE), HiiEnvHandle, FilePath->PathName);
650     break;
651
652   case MEDIA_PROTOCOL_DP:
653     MediaProtocol = (MEDIA_PROTOCOL_DEVICE_PATH *) DevicePath;
654     PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_PROTOCOL_2), HiiEnvHandle, &MediaProtocol->Protocol);
655     break;
656
657   case MEDIA_RELATIVE_OFFSET_RANGE_DP:
658     Offset = (MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH *) DevicePath;
659     PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_OFFSET), HiiEnvHandle, Offset->StartingOffset, Offset->EndingOffset);
660
661   };
662
663   //
664   // End processing
665   //
666 }
667
668 struct DevicePathTypes  SEnvDP_Strings[] = {
669   0x00,
670   0x01,
671   L"Illegal",
672   SEnvDP_IlleagalStr,
673   NULL,
674   0x01,
675   0x05,
676   L"Hardware",
677   SEnvDP_HardwareStr,
678   SEnvHardwareDevicePathEntry,
679   0x02,
680   0x03,
681   L"ACPI",
682   SEnvDP_ACPI_Str,
683   SEnvAcpiDevicePathEntry,
684   0x03,
685   0x13,
686   L"Messaging",
687   SEnvDP_MessageStr,
688   SEnvMessagingDevicePathEntry,
689   0x04,
690   0x08,
691   L"Media",
692   SEnvDP_MediaStr,
693   SEnvMediaDevicePathEntry,
694   0x05,
695   0x01,
696   L"BIOS Boot Spec",
697   SEnvDP_BBS_Str,
698   NULL,
699
700   END_DEVICE_PATH_TYPE,
701   0x01,
702   L"End",
703   SEnvDP_IlleagalStr,
704   NULL
705 };
706
707 VOID
708 SEnvPrintDevicePathEntry (
709   IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath,
710   IN BOOLEAN                      Verbose
711   )
712 /*++
713
714 Routine Description:
715
716 Arguments:
717
718   DevicePath - The device path
719   Verbose    - Verbose
720 Returns:
721
722 --*/
723 {
724   UINT8 Type;
725   UINT8 SubType;
726   INTN  Index;
727
728   //
729   // Process print device path entry
730   //
731   Type    = (UINT8) DevicePathType (DevicePath);
732   SubType = DevicePathSubType (DevicePath);
733
734   for (Index = 0; SEnvDP_Strings[Index].Type != END_DEVICE_PATH_TYPE; Index++) {
735     if (Type == SEnvDP_Strings[Index].Type) {
736       if (SubType > SEnvDP_Strings[Index].MaxSubType) {
737         SubType = 0;
738       }
739
740       PrintToken (
741         STRING_TOKEN (STR_SHELLENV_DPROT_DEVICE_PATH_FOR),
742         HiiEnvHandle,
743         SEnvDP_Strings[Index].TypeString,
744         SEnvDP_Strings[Index].SubTypeStr[SubType]
745         );
746       if (Verbose) {
747         if (SEnvDP_Strings[Index].Function != NULL) {
748           SEnvDP_Strings[Index].Function (DevicePath);
749         }
750       }
751
752       return ;
753     }
754   }
755
756   PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_DEVICE_PATH_ERROR), HiiEnvHandle);
757 }
758
759 VOID
760 EFIAPI
761 SEnvDPath (
762   IN EFI_HANDLE           h,
763   IN VOID                 *Interface
764   )
765 /*++
766
767 Routine Description:
768
769 Arguments:
770
771   h         - An EFI handle
772   Interface - The interface
773
774 Returns:
775
776 --*/
777 {
778   EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
779   EFI_DEVICE_PATH_PROTOCOL  *DevicePathNode;
780   CHAR16                    *Str;
781
782   DevicePath  = Interface;
783   Str         = LibDevicePathToStr (DevicePath);
784   DevicePath  = UnpackDevicePath (DevicePath);
785
786   //
787   // Print device path entry
788   //
789   DevicePathNode = DevicePath;
790   while (!IsDevicePathEnd (DevicePathNode)) {
791     SEnvPrintDevicePathEntry (DevicePathNode, TRUE);
792     DevicePathNode = NextDevicePathNode (DevicePathNode);
793   }
794
795   PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_ASSTR), HiiEnvHandle, Str);
796   FreePool (Str);
797   FreePool (DevicePath);
798 }
799
800 VOID
801 EFIAPI
802 SEnvDPathTok (
803   IN EFI_HANDLE   h,
804   IN VOID         *Interface
805   )
806 /*++
807
808 Routine Description:
809
810 Arguments:
811
812   h         - An EFI handle
813   Interface - The interface
814
815 Returns:
816
817 --*/
818 {
819   EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
820   CHAR16                    *Str;
821   CHAR16                    *Disp;
822   UINTN                     Len;
823
824   DevicePath  = Interface;
825   Str         = LibDevicePathToStr (DevicePath);
826   Disp        = L"";
827
828   //
829   // Print device path token
830   //
831   if (Str) {
832     Len   = StrLen (Str);
833     Disp  = Str;
834     if (Len > 30) {
835       Disp    = Str + Len - 30;
836       Disp[0] = '.';
837       Disp[1] = '.';
838     }
839   }
840
841   PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_DEVPATH), HiiEnvHandle, Disp);
842
843   if (Str) {
844     FreePool (Str);
845   }
846 }
847
848 VOID
849 EFIAPI
850 SEnvImageDPathTok (
851   IN EFI_HANDLE   h,
852   IN VOID         *Interface
853   )
854 /*++
855
856 Routine Description:
857
858 Arguments:
859
860   h         - An EFI handle
861   Interface - The interface
862
863 Returns:
864
865 --*/
866 {
867   EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
868   CHAR16                    *Str;
869   CHAR16                    *Disp;
870   UINTN                     Len;
871
872   DevicePath  = Interface;
873   Str         = LibDevicePathToStr (DevicePath);
874   Disp        = L"";
875
876   //
877   // Print device path token
878   //
879   if (Str) {
880     Len   = StrLen (Str);
881     Disp  = Str;
882     if (Len > 30) {
883       Disp    = Str + Len - 30;
884       Disp[0] = '.';
885       Disp[1] = '.';
886     }
887   }
888
889   PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_IMAGE_DEVPATH), HiiEnvHandle, Disp);
890
891   if (Str) {
892     FreePool (Str);
893   }
894 }
895
896 VOID
897 EFIAPI
898 SEnvTextOut (
899   IN EFI_HANDLE   h,
900   IN VOID         *Interface
901   )
902 /*++
903
904 Routine Description:
905
906 Arguments:
907
908   h         - An EFI handle
909   Interface - The interface
910
911 Returns:
912
913 --*/
914 {
915   EFI_SIMPLE_TEXT_OUT_PROTOCOL  *Dev;
916   INTN                          Index;
917   UINTN                         Col;
918   UINTN                         Row;
919   EFI_STATUS                    Status;
920
921   Dev = Interface;
922
923   PrintToken (
924     STRING_TOKEN (STR_SHELLENV_DPROT_ATTRIB_X),
925     HiiEnvHandle,
926     Dev->Mode->Attribute
927     );
928
929   //
930   // Dump TextOut Info
931   //
932   for (Index = 0; Index < Dev->Mode->MaxMode; Index++) {
933     Status = Dev->QueryMode (Dev, Index, &Col, &Row);
934     PrintToken (
935       STRING_TOKEN (STR_SHELLENV_DPROT_MODE),
936       HiiEnvHandle,
937       Index == Dev->Mode->Mode ? '*' : ' ',
938       Index
939       );
940
941     if (EFI_ERROR (Status)) {
942       PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_ERROR), HiiEnvHandle, Status);
943     } else {
944       PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_COL_ROW), HiiEnvHandle, Col, Row);
945     }
946   }
947 }
948
949 VOID
950 EFIAPI
951 SEnvBlkIo (
952   IN EFI_HANDLE   h,
953   IN VOID         *Interface
954   )
955 /*++
956
957 Routine Description:
958
959 Arguments:
960
961   h         - An EFI handle
962   Interface - The interface
963
964 Returns:
965
966 --*/
967 {
968   EFI_BLOCK_IO_PROTOCOL *BlkIo;
969   EFI_BLOCK_IO_MEDIA    *BlkMedia;
970   VOID                  *Buffer;
971
972   BlkIo     = Interface;
973   BlkMedia  = BlkIo->Media;
974
975   //
976   // Issue a dummy read to the device to check for media change
977   //
978   Buffer = AllocatePool (BlkMedia->BlockSize);
979   if (Buffer) {
980     BlkIo->ReadBlocks (
981             BlkIo,
982             BlkMedia->MediaId,
983             0,
984             BlkMedia->BlockSize,
985             Buffer
986             );
987     FreePool (Buffer);
988   }
989   //
990   // Dump BlkIo Info
991   //
992   PrintToken (
993     STRING_TOKEN (STR_SHELLENV_DPROT_MID),
994     HiiEnvHandle,
995     BlkMedia->RemovableMedia ? L"Removable " : L"Fixed ",
996     BlkMedia->MediaPresent ? L"" : L"not-present ",
997     BlkMedia->MediaId
998     );
999
1000   PrintToken (
1001     STRING_TOKEN (STR_SHELLENV_DPROT_BSIZE_LBLOCK),
1002     HiiEnvHandle,
1003     BlkMedia->BlockSize,
1004     BlkMedia->LastBlock,
1005     MultU64x32 (BlkMedia->LastBlock + 1, BlkMedia->BlockSize),
1006     BlkMedia->LogicalPartition ? L"partition" : L"raw",
1007     BlkMedia->ReadOnly ? L"ro" : L"rw",
1008     BlkMedia->WriteCaching ? L"cached" : L"!cached"
1009     );
1010 }
1011
1012 CHAR8 *
1013 GetPdbPath (
1014   VOID *ImageBase
1015   )
1016 /*++
1017
1018 Routine Description:
1019   Located PDB path name in PE image
1020
1021 Arguments:
1022   ImageBase - base of PE to search
1023
1024 Returns:
1025   Pointer into image at offset of PDB file name if PDB file name is found,
1026   Otherwise a pointer to an empty string.
1027   
1028 --*/
1029 {
1030   CHAR8                           *PdbPath;
1031   UINT32                          DirCount;
1032   EFI_IMAGE_DOS_HEADER            *DosHdr;
1033   EFI_IMAGE_NT_HEADERS            *NtHdr;
1034   UINT16                          Magic;
1035   EFI_IMAGE_OPTIONAL_HEADER32     *OptionalHdr32;
1036   EFI_IMAGE_OPTIONAL_HEADER64     *OptionalHdr64;
1037   EFI_IMAGE_DATA_DIRECTORY        *DirectoryEntry;
1038   EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *DebugEntry;
1039   VOID                            *CodeViewEntryPointer;
1040
1041   CodeViewEntryPointer  = NULL;
1042   PdbPath               = NULL;
1043   DosHdr                = ImageBase;
1044   if (DosHdr && DosHdr->e_magic == EFI_IMAGE_DOS_SIGNATURE) {
1045     NtHdr           = (EFI_IMAGE_NT_HEADERS *) ((UINT8 *) DosHdr + DosHdr->e_lfanew);
1046     //
1047     // NOTE: We use Machine to identify PE32/PE32+, instead of Magic.
1048     //       It is for backward-compatibility consideration, because
1049     //       some system will generate PE32+ image with PE32 Magic.
1050     //
1051     if (NtHdr->FileHeader.Machine == EFI_IMAGE_MACHINE_IA32) {
1052       Magic = EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC;
1053     } else if (NtHdr->FileHeader.Machine == EFI_IMAGE_MACHINE_IA64) {
1054       Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC;
1055     } else if (NtHdr->FileHeader.Machine == EFI_IMAGE_MACHINE_X64) {
1056       Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC;
1057     } else {
1058       Magic = NtHdr->OptionalHeader.Magic;
1059     }
1060     if (Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
1061       OptionalHdr32 = (VOID *) &NtHdr->OptionalHeader;
1062       DirectoryEntry  = (EFI_IMAGE_DATA_DIRECTORY *) &(OptionalHdr32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);
1063     } else {
1064       OptionalHdr64 = (VOID *) &NtHdr->OptionalHeader;
1065       DirectoryEntry  = (EFI_IMAGE_DATA_DIRECTORY *) &(OptionalHdr64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);
1066     }
1067     
1068     if (DirectoryEntry->VirtualAddress != 0) {
1069       for (DirCount = 0;
1070            (DirCount < DirectoryEntry->Size / sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY)) && CodeViewEntryPointer == NULL;
1071            DirCount++
1072           ) {
1073         DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *) (DirectoryEntry->VirtualAddress + (UINTN) ImageBase + DirCount * sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY));
1074         if (DebugEntry->Type == EFI_IMAGE_DEBUG_TYPE_CODEVIEW) {
1075           CodeViewEntryPointer = (VOID *) ((UINTN) DebugEntry->RVA + (UINTN) ImageBase);
1076           switch (*(UINT32 *) CodeViewEntryPointer) {
1077           case CODEVIEW_SIGNATURE_NB10:
1078             PdbPath = (CHAR8 *) CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY);
1079             break;
1080
1081           case CODEVIEW_SIGNATURE_RSDS:
1082             PdbPath = (CHAR8 *) CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_RSDS_ENTRY);
1083             break;
1084
1085           default:
1086             break;
1087           }
1088         }
1089       }
1090     }
1091   }
1092
1093   return PdbPath;
1094 }
1095
1096 VOID
1097 PrintShortPdbFileName (
1098   CHAR8  *PdbFileName,
1099   UINTN  Length
1100   )
1101 /*++
1102
1103 Routine Description:
1104
1105 Arguments:
1106
1107   PdbFileName  - The pdb file name
1108   Length       - The length
1109
1110 Returns:
1111
1112 --*/
1113 {
1114   UINTN Index;
1115   UINTN StartIndex;
1116   UINTN EndIndex;
1117
1118   if (PdbFileName == NULL) {
1119     Print (L"NULL");
1120   } else {
1121     StartIndex = 0;
1122     for (EndIndex = 0; PdbFileName[EndIndex] != 0; EndIndex++)
1123       ;
1124     for (Index = 0; PdbFileName[Index] != 0; Index++) {
1125       if (PdbFileName[Index] == '\\') {
1126         StartIndex = Index + 1;
1127       }
1128
1129       if (PdbFileName[Index] == '.') {
1130         EndIndex = Index;
1131       }
1132     }
1133
1134     for (Index = StartIndex; Index < EndIndex && Length > 0; Index++, Length--) {
1135       Print (L"%c", PdbFileName[Index]);
1136     }
1137   }
1138 }
1139
1140 VOID
1141 EFIAPI
1142 SEnvImageTok (
1143   IN EFI_HANDLE       h,
1144   IN VOID             *Interface
1145   )
1146 /*++
1147
1148 Routine Description:
1149
1150 Arguments:
1151
1152   h         - An EFI handle
1153   Interface - The interface
1154
1155 Returns:
1156
1157 --*/
1158 {
1159   EFI_LOADED_IMAGE_PROTOCOL *Image;
1160   CHAR16                    *ImageName;
1161
1162   CHAR16                    *Tok;
1163
1164   Image     = Interface;
1165   ImageName = LibGetImageName (Image);
1166   if (ImageName != NULL) {
1167     PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_IMAGE_2), HiiEnvHandle);
1168     Print (ImageName);
1169     Print (L") ");
1170     FreePool (ImageName);
1171   } else {
1172     Tok = LibDevicePathToStr (Image->FilePath);
1173     PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_IMAGE), HiiEnvHandle, Tok);
1174     FreePool (Tok);
1175   }
1176 }
1177
1178 VOID
1179 EFIAPI
1180 SEnvImage (
1181   IN EFI_HANDLE       h,
1182   IN VOID             *Interface
1183   )
1184 /*++
1185
1186 Routine Description:
1187
1188 Arguments:
1189
1190   h         - An EFI handle
1191   Interface - The interface
1192
1193 Returns:
1194
1195 --*/
1196 {
1197   EFI_LOADED_IMAGE_PROTOCOL *Image;
1198   CHAR16                    *FilePath;
1199   CHAR8                     *PdbFileName;
1200   CHAR16                    *ImageName;
1201
1202   Image       = Interface;
1203
1204   FilePath    = LibDevicePathToStr (Image->FilePath);
1205   PdbFileName = GetPdbPath (Image->ImageBase);
1206   ImageName   = LibGetImageName (Image);
1207
1208   if (ImageName != NULL) {
1209     PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_FILE_3), HiiEnvHandle);
1210     Print (ImageName);
1211     PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_ONE_VAR_N_NEW), HiiEnvHandle);
1212     FreePool (ImageName);
1213   } else {
1214     PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_FILE_2), HiiEnvHandle, FilePath);
1215   }
1216   //
1217   // Dump Image Info
1218   //
1219   if (!Image->ImageBase) {
1220     PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_INTERNAL_IMAGE), HiiEnvHandle, FilePath);
1221     PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_CODETYPE), HiiEnvHandle, MemoryTypeStr (Image->ImageCodeType));
1222     PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_DATATYPE_NEWLINE), HiiEnvHandle, MemoryTypeStr (Image->ImageDataType));
1223   } else {
1224     PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_PARENTHANDLE), HiiEnvHandle, Image->ParentHandle);
1225     PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_SYSTEMTABLE), HiiEnvHandle, Image->SystemTable);
1226     PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_DEVICEHANDLE), HiiEnvHandle, Image->DeviceHandle);
1227     PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_FILEPATH), HiiEnvHandle, FilePath);
1228     if (PdbFileName != NULL) {
1229       PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_PDBFILENAME), HiiEnvHandle, PdbFileName);
1230     }
1231
1232     PrintToken (
1233       STRING_TOKEN (STR_SHELLENV_DPROT_IMAGEBASE),
1234       HiiEnvHandle,
1235       Image->ImageBase,
1236       (CHAR8 *) Image->ImageBase + Image->ImageSize
1237       );
1238     PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_IMAGESIZE), HiiEnvHandle, Image->ImageSize);
1239     PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_CODETYPE), HiiEnvHandle, MemoryTypeStr (Image->ImageCodeType));
1240     PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_DATATYPE), HiiEnvHandle, MemoryTypeStr (Image->ImageDataType));
1241   }
1242
1243   if (FilePath) {
1244     FreePool (FilePath);
1245   }
1246 }
1247
1248 VOID
1249 EFIAPI
1250 SEnvIsaIo (
1251   IN EFI_HANDLE       h,
1252   IN VOID             *Interface
1253   )
1254 /*++
1255
1256 Routine Description:
1257
1258 Arguments:
1259
1260   h         - An EFI handle
1261   Interface - The interface
1262
1263 Returns:
1264
1265 --*/
1266 {
1267   EFI_ISA_IO_PROTOCOL *IsaIo;
1268   UINTN               Index;
1269
1270   IsaIo = Interface;
1271
1272   //
1273   // Dump IsaIo Info
1274   //
1275   Print (L"\n");
1276   PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_ROM_SIZE), HiiEnvHandle, IsaIo->RomSize);
1277   PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_ROM_LOCATION), HiiEnvHandle, IsaIo->RomImage);
1278
1279   PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_ISA_RESOURCE_LIST), HiiEnvHandle);
1280   for (Index = 0; IsaIo->ResourceList->ResourceItem[Index].Type != EfiIsaAcpiResourceEndOfList; Index++) {
1281     switch (IsaIo->ResourceList->ResourceItem[Index].Type) {
1282     case EfiIsaAcpiResourceIo:
1283       PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_IO), HiiEnvHandle);
1284       break;
1285
1286     case EfiIsaAcpiResourceMemory:
1287       PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_MEM), HiiEnvHandle);
1288       break;
1289
1290     case EfiIsaAcpiResourceDma:
1291       PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_DMA), HiiEnvHandle);
1292       break;
1293
1294     case EfiIsaAcpiResourceInterrupt:
1295       PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_INT), HiiEnvHandle);
1296       break;
1297     }
1298
1299     if (IsaIo->ResourceList->ResourceItem[Index].StartRange == IsaIo->ResourceList->ResourceItem[Index].EndRange) {
1300       PrintToken (
1301         STRING_TOKEN (STR_SHELLENV_DPROT_ATTR),
1302         HiiEnvHandle,
1303         IsaIo->ResourceList->ResourceItem[Index].StartRange,
1304         IsaIo->ResourceList->ResourceItem[Index].EndRange,
1305         IsaIo->ResourceList->ResourceItem[Index].Attribute
1306         );
1307     } else {
1308       PrintToken (
1309         STRING_TOKEN (STR_SHELLENV_DPROT_ATTR_2),
1310         HiiEnvHandle,
1311         IsaIo->ResourceList->ResourceItem[Index].StartRange,
1312         IsaIo->ResourceList->ResourceItem[Index].EndRange,
1313         IsaIo->ResourceList->ResourceItem[Index].Attribute
1314         );
1315     }
1316   }
1317 }
1318
1319 VOID
1320 EFIAPI
1321 SEnvPciRootBridgeIo (
1322   IN EFI_HANDLE       h,
1323   IN VOID             *Interface
1324   )
1325 /*++
1326 Routine Description:
1327
1328 Arguments:
1329
1330   h         - An EFI handle
1331   Interface - The interface
1332
1333 Returns:
1334
1335 --*/
1336 {
1337   EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL   *PciRootBridgeIo;
1338   EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR *Configuration;
1339   UINT64                            Supports;
1340   UINT64                            Attributes;
1341
1342   PciRootBridgeIo = Interface;
1343
1344   Configuration   = NULL;
1345   PciRootBridgeIo->Configuration (PciRootBridgeIo, (VOID **) &Configuration);
1346   PciRootBridgeIo->GetAttributes (PciRootBridgeIo, &Supports, &Attributes);
1347
1348   //
1349   // Dump PciRootBridgeIo Info
1350   //
1351   Print (L"\n");
1352   PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_PARENTHANDLE), HiiEnvHandle, PciRootBridgeIo->ParentHandle);
1353   PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_SEGMENT), HiiEnvHandle, PciRootBridgeIo->SegmentNumber);
1354   PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_ATTRIBUTES), HiiEnvHandle, Attributes);
1355   PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_SUPPORTS), HiiEnvHandle, Supports);
1356
1357   if (Configuration != NULL) {
1358     Print (L"\n");
1359     PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_TYPE_FLAG), HiiEnvHandle);
1360     Print (L"      ====  ====  ================  ================  ====");
1361     while (Configuration->Desc == ACPI_ADDRESS_SPACE_DESCRIPTOR) {
1362       Print (L"\n");
1363       switch (Configuration->ResType) {
1364       case ACPI_ADDRESS_SPACE_TYPE_MEM:
1365         Print (L"      MEM : ");
1366         break;
1367
1368       case ACPI_ADDRESS_SPACE_TYPE_IO:
1369         Print (L"      I/O : ");
1370         break;
1371
1372       case ACPI_ADDRESS_SPACE_TYPE_BUS:
1373         PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_BUS), HiiEnvHandle);
1374         break;
1375       }
1376
1377       PrintToken (
1378         STRING_TOKEN (STR_SHELLENV_DPROT_FOUR_VARS),
1379         HiiEnvHandle,
1380         Configuration->SpecificFlag,
1381         Configuration->AddrRangeMin,
1382         Configuration->AddrRangeMax,
1383         Configuration->AddrSpaceGranularity
1384         );
1385       Configuration++;
1386     }
1387   }
1388 }
1389
1390 VOID
1391 EFIAPI
1392 SEnvPciIo (
1393   IN EFI_HANDLE       h,
1394   IN VOID             *Interface
1395   )
1396 /*++
1397
1398 Routine Description:
1399
1400 Arguments:
1401
1402   h         - An EFI handle
1403   Interface - The interface
1404
1405 Returns:
1406
1407 --*/
1408 {
1409   EFI_PCI_IO_PROTOCOL *PciIo;
1410   PCI_TYPE00          Pci;
1411   UINTN               Segment;
1412   UINTN               Bus;
1413   UINTN               Device;
1414   UINTN               Function;
1415   UINTN               Index;
1416
1417   PciIo = Interface;
1418
1419   PciIo->Pci.Read (PciIo, EfiPciIoWidthUint8, 0, sizeof (Pci), &Pci);
1420
1421   PciIo->GetLocation (PciIo, &Segment, &Bus, &Device, &Function);
1422
1423   //
1424   // Dump PciIo Info
1425   //
1426   Print (L"\n");
1427   PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_SEGMENT_2), HiiEnvHandle, Segment);
1428   PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_BUS_2), HiiEnvHandle, Bus);
1429   PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_DEVICE_NUMBER), HiiEnvHandle, Device);
1430   PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_FUNCTION_NUMBER_2), HiiEnvHandle, Function);
1431   PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_ROM_SIZE_2), HiiEnvHandle, PciIo->RomSize);
1432   PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_ROM_LOCATION), HiiEnvHandle, PciIo->RomImage);
1433   PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_VENDOR_ID), HiiEnvHandle, Pci.Hdr.VendorId);
1434   PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_DEVICE_ID_2), HiiEnvHandle, Pci.Hdr.DeviceId);
1435   PrintToken (
1436     STRING_TOKEN (STR_SHELLENV_DPROT_CLASS_CODE),
1437     HiiEnvHandle,
1438     Pci.Hdr.ClassCode[0],
1439     Pci.Hdr.ClassCode[1],
1440     Pci.Hdr.ClassCode[2]
1441     );
1442   PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_CONFIG_HEADER), HiiEnvHandle);
1443   for (Index = 0; Index < sizeof (Pci); Index++) {
1444     if ((Index % 0x10) == 0) {
1445       Print (L"\n       ");
1446     }
1447
1448     PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_ONE_VAR_X), HiiEnvHandle, *((UINT8 *) (&Pci) + Index));
1449   }
1450
1451   Print (L"\n");
1452 }
1453
1454 VOID
1455 EFIAPI
1456 SEnvUsbIo (
1457   IN EFI_HANDLE       h,
1458   IN VOID             *Interface
1459   )
1460 /*++
1461
1462 Routine Description:
1463
1464 Arguments:
1465
1466   h         - An EFI handle
1467   Interface - The interface
1468
1469 Returns:
1470
1471 --*/
1472 {
1473   EFI_USB_IO_PROTOCOL           *UsbIo;
1474   EFI_USB_INTERFACE_DESCRIPTOR  InterfaceDesc;
1475
1476   UsbIo = Interface;
1477
1478   UsbIo->UsbGetInterfaceDescriptor (UsbIo, &InterfaceDesc);
1479
1480   //
1481   // Dump UsbIo Info
1482   //
1483   Print (L"\n");
1484   PrintToken (
1485     STRING_TOKEN (STR_SHELLENV_DPROT_INTERFACE_NUMBER),
1486     HiiEnvHandle,
1487     InterfaceDesc.InterfaceNumber
1488     );
1489   PrintToken (
1490     STRING_TOKEN (STR_SHELLENV_DPROT_INTERFACE_CLASS),
1491     HiiEnvHandle,
1492     InterfaceDesc.InterfaceClass
1493     );
1494   PrintToken (
1495     STRING_TOKEN (STR_SHELLENV_DPROT_INTERFACE_SUBCLASS),
1496     HiiEnvHandle,
1497     InterfaceDesc.InterfaceSubClass
1498     );
1499   PrintToken (
1500     STRING_TOKEN (STR_SHELLENV_DPROT_INTERFACE_PROTOCOL),
1501     HiiEnvHandle,
1502     InterfaceDesc.InterfaceProtocol
1503     );
1504 }
1505
1506 VOID
1507 EFIAPI
1508 SEnvDebugSupport (
1509   IN EFI_HANDLE       h,
1510   IN VOID             *Interface
1511   )
1512 /*++
1513 Routine Description:
1514
1515 Arguments:
1516
1517   h         - An EFI handle
1518   Interface - The interface
1519
1520 Returns:
1521
1522 --*/
1523 {
1524   EFI_DEBUG_SUPPORT_PROTOCOL  *DebugSupport;
1525
1526   DebugSupport = Interface;
1527
1528   //
1529   // Dump Debug support info
1530   //
1531   Print (L"\n");
1532   Print (L"Isa = ");
1533   switch (DebugSupport->Isa) {
1534   case (IsaIa32):
1535     Print (L"IA-32");
1536     break;
1537
1538   case (IsaIpf):
1539     Print (L"IPF");
1540     break;
1541
1542   case (IsaEbc):
1543     Print (L"EBC");
1544     break;
1545
1546   default:
1547     PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_UNKNOWN), HiiEnvHandle, DebugSupport->Isa);
1548     break;
1549   }
1550 }
1551
1552 VOID
1553 EFIAPI
1554 SEnvBusSpecificDriverOverride (
1555   IN EFI_HANDLE       h,
1556   IN VOID             *Interface
1557   )
1558 /*++
1559
1560 Routine Description:
1561
1562 Arguments:
1563
1564   h         - An EFI handle
1565   Interface - The interface
1566
1567 Returns:
1568
1569 --*/
1570 {
1571   EFI_STATUS                                Status;
1572   EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL *BusSpecificDriverOverride;
1573   EFI_HANDLE                                ImageHandle;
1574   EFI_LOADED_IMAGE_PROTOCOL                 *Image;
1575
1576   Print (L"\n");
1577   BusSpecificDriverOverride = Interface;
1578   do {
1579     Status = BusSpecificDriverOverride->GetDriver (
1580                                           BusSpecificDriverOverride,
1581                                           &ImageHandle
1582                                           );
1583     if (!EFI_ERROR (Status)) {
1584       Status = BS->HandleProtocol (
1585                     ImageHandle,
1586                     &gEfiLoadedImageProtocolGuid,
1587                     (VOID **) &Image
1588                     );
1589       if (!EFI_ERROR (Status)) {
1590         PrintToken (
1591           STRING_TOKEN (STR_SHELLENV_DPROT_DRV_FILE),
1592           HiiEnvHandle,
1593           SEnvHandleToNumber (ImageHandle),
1594           LibDevicePathToStr (Image->FilePath)
1595           );
1596       }
1597     }
1598   } while (!EFI_ERROR (Status));
1599 }
1600
1601 VOID
1602 EFIAPI
1603 SEnvGraphicsOutput (
1604   IN EFI_HANDLE      h,
1605   IN VOID            *Interface
1606   )
1607 {
1608   EFI_GRAPHICS_OUTPUT_PROTOCOL           *GraphicsOutput;
1609   EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE      *Mode;
1610   EFI_GRAPHICS_OUTPUT_MODE_INFORMATION   *Info;
1611
1612   GraphicsOutput = (EFI_GRAPHICS_OUTPUT_PROTOCOL *) Interface;
1613   Mode           = GraphicsOutput->Mode;
1614   Info           = Mode->Info;
1615
1616   //
1617   // Dump GraphicsOutput Info:
1618   // HorizontalResolution
1619   // VerticalResolution
1620   // PixelFormat
1621   // PixelInformation
1622   // PixelPerScanLine
1623   // FrameBufferBase
1624   // FrameBufferSize
1625   //
1626   PrintToken (
1627     STRING_TOKEN (STR_SHELLENV_DPROT_HRESOL),
1628     HiiEnvHandle,
1629     Info->HorizontalResolution
1630     );
1631   PrintToken (
1632     STRING_TOKEN (STR_SHELLENV_DPROT_VRESOL),
1633     HiiEnvHandle,
1634     Info->VerticalResolution
1635     );
1636   PrintToken (
1637     STRING_TOKEN (STR_SHELLENV_DPROT_PIXELFORMAT),
1638     HiiEnvHandle
1639     );
1640   switch (Info->PixelFormat) {
1641   case PixelRedGreenBlueReserved8BitPerColor:
1642     Print (L"PixelRedGreenBlueReserved8BitPerColor");
1643     break;
1644   case PixelBlueGreenRedReserved8BitPerColor:
1645     Print (L"PixelBlueGreenRedReserved8BitPerColor");
1646     break;
1647   case PixelBitMask:
1648     Print (L"PixelBitMask");
1649     PrintToken (
1650       STRING_TOKEN (STR_SHELLENV_DPROT_PIXELINFORMATION),
1651       HiiEnvHandle,
1652       Info->PixelInformation.RedMask,
1653       Info->PixelInformation.GreenMask,
1654       Info->PixelInformation.BlueMask,
1655       Info->PixelInformation.ReservedMask
1656       );
1657     break;
1658   case PixelBltOnly:
1659     Print (L"PixelBltOnly");
1660     break;
1661   default:
1662     Print (L"Unknown");
1663     break;
1664   }
1665   PrintToken (
1666     STRING_TOKEN (STR_SHELLENV_DPROT_PIXELSPERSCANLINE),
1667     HiiEnvHandle,
1668     Info->PixelsPerScanLine
1669     );
1670   PrintToken (
1671     STRING_TOKEN (STR_SHELLENV_DPROT_FRAMEBUFFERBASE),
1672     HiiEnvHandle,
1673     Mode->FrameBufferBase
1674     );
1675   PrintToken (
1676     STRING_TOKEN (STR_SHELLENV_DPROT_FRAMEBUFFERSIZE),
1677     HiiEnvHandle,
1678     Mode->FrameBufferSize
1679     );
1680 }
1681
1682 VOID
1683 EFIAPI
1684 SEnvDriverEFIVersion (
1685   IN EFI_HANDLE      h,
1686   IN VOID            *Interface
1687   )
1688 {
1689   EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL *DriverEfiVersion;
1690
1691   DriverEfiVersion = (EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL *) Interface;
1692   PrintToken (
1693     STRING_TOKEN (STR_SHELLENV_PROTID_DRV_EFI_VER),
1694     HiiEnvHandle,
1695     DriverEfiVersion->FirmwareVersion
1696     );
1697 }
1698
1699 VOID
1700 EFIAPI
1701 SEnvDriverEFIVersionTok (
1702   IN EFI_HANDLE      h,
1703   IN VOID            *Interface
1704   )
1705 {
1706   EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL *DriverEfiVersion;
1707
1708   DriverEfiVersion = (EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL *) Interface;
1709   PrintToken (
1710     STRING_TOKEN (STR_SHELLENV_PROTID_DRV_EFI_VER_TOK),
1711     HiiEnvHandle,
1712     DriverEfiVersion->FirmwareVersion
1713     );
1714 }