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