MdeModulePkg/Universal/DevicePathDxe/DevicePathToText.c

   1 /** @file
   2   DevicePathToText protocol as defined in the UEFI 2.0 specification.
   3
   4 Copyright (c) 2006 - 2008, Intel Corporation. <BR>
   5 All rights reserved. This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "DevicePath.h"
  16
  17 /**
  18   Concatenates a formatted unicode string to allocated pool. The caller must
  19   free the resulting buffer.
  20
  21   @param Str             Tracks the allocated pool, size in use, and
  22                          amount of pool allocated.
  23   @param Fmt             The format string
  24   @param ...             Variable arguments based on the format string.
  25
  26   @return Allocated buffer with the formatted string printed in it.
  27           The caller must free the allocated buffer. The buffer
  28           allocation is not packed.
  29
  30 **/
  31 CHAR16 *
  32 CatPrint (
  33   IN OUT POOL_PRINT   *Str,
  34   IN CHAR16           *Fmt,
  35   ...
  36   )
  37 {
  38   UINT16  *AppendStr;
  39   VA_LIST Args;
  40   UINTN   Size;
  41
  42   AppendStr = AllocateZeroPool (0x1000);
  43   if (AppendStr == NULL) {
  44     return Str->Str;
  45   }
  46
  47   VA_START (Args, Fmt);
  48   UnicodeVSPrint (AppendStr, 0x1000, Fmt, Args);
  49   VA_END (Args);
  50   if (NULL == Str->Str) {
  51     Size   = StrSize (AppendStr);
  52     Str->Str  = AllocateZeroPool (Size);
  53     ASSERT (Str->Str != NULL);
  54   } else {
  55     Size = StrSize (AppendStr) - sizeof (UINT16);
  56     Size = Size + StrSize (Str->Str);
  57     Str->Str = ReallocatePool (
  58                  StrSize (Str->Str),
  59                  Size,
  60                  Str->Str
  61                  );
  62     ASSERT (Str->Str != NULL);
  63   }
  64
  65   Str->MaxLen = MAX_CHAR * sizeof (UINT16);
  66   if (Size < Str->MaxLen) {
  67     StrCat (Str->Str, AppendStr);
  68     Str->Len = Size - sizeof (UINT16);
  69   }
  70
  71   FreePool (AppendStr);
  72   return Str->Str;
  73 }
  74
  75 /**
  76   Converts a PCI device path structure to its string representative.
  77
  78   @param Str             The string representative of input device.
  79   @param DevPath         The input device path structure.
  80   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
  81                          of the display node is used, where applicable. If DisplayOnly
  82                          is FALSE, then the longer text representation of the display node
  83                          is used.
  84   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
  85                          representation for a device node can be used, where applicable.
  86
  87 **/
  88 VOID
  89 DevPathToTextPci (
  90   IN OUT POOL_PRINT  *Str,
  91   IN VOID            *DevPath,
  92   IN BOOLEAN         DisplayOnly,
  93   IN BOOLEAN         AllowShortcuts
  94   )
  95 {
  96   PCI_DEVICE_PATH *Pci;
  97
  98   Pci = DevPath;
  99   CatPrint (Str, L"Pci(0x%x,0x%x)", Pci->Device, Pci->Function);
 100 }
 101
 102 /**
 103   Converts a PC Card device path structure to its string representative.
 104
 105   @param Str             The string representative of input device.
 106   @param DevPath         The input device path structure.
 107   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 108                          of the display node is used, where applicable. If DisplayOnly
 109                          is FALSE, then the longer text representation of the display node
 110                          is used.
 111   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 112                          representation for a device node can be used, where applicable.
 113
 114 **/
 115 VOID
 116 DevPathToTextPccard (
 117   IN OUT POOL_PRINT  *Str,
 118   IN VOID            *DevPath,
 119   IN BOOLEAN         DisplayOnly,
 120   IN BOOLEAN         AllowShortcuts
 121   )
 122 {
 123   PCCARD_DEVICE_PATH  *Pccard;
 124
 125   Pccard = DevPath;
 126   CatPrint (Str, L"PcCard(0x%x)", Pccard->FunctionNumber);
 127 }
 128
 129 /**
 130   Converts a Memory Map device path structure to its string representative.
 131
 132   @param Str             The string representative of input device.
 133   @param DevPath         The input device path structure.
 134   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 135                          of the display node is used, where applicable. If DisplayOnly
 136                          is FALSE, then the longer text representation of the display node
 137                          is used.
 138   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 139                          representation for a device node can be used, where applicable.
 140
 141 **/
 142 VOID
 143 DevPathToTextMemMap (
 144   IN OUT POOL_PRINT  *Str,
 145   IN VOID            *DevPath,
 146   IN BOOLEAN         DisplayOnly,
 147   IN BOOLEAN         AllowShortcuts
 148   )
 149 {
 150   MEMMAP_DEVICE_PATH  *MemMap;
 151
 152   MemMap = DevPath;
 153   CatPrint (
 154     Str,
 155     L"MemoryMapped(0x%x,0x%lx,0x%lx)",
 156     MemMap->MemoryType,
 157     MemMap->StartingAddress,
 158     MemMap->EndingAddress
 159     );
 160 }
 161
 162 /**
 163   Converts a Vendor device path structure to its string representative.
 164
 165   @param Str             The string representative of input device.
 166   @param DevPath         The input device path structure.
 167   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 168                          of the display node is used, where applicable. If DisplayOnly
 169                          is FALSE, then the longer text representation of the display node
 170                          is used.
 171   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 172                          representation for a device node can be used, where applicable.
 173
 174 **/
 175 VOID
 176 DevPathToTextVendor (
 177   IN OUT POOL_PRINT  *Str,
 178   IN VOID            *DevPath,
 179   IN BOOLEAN         DisplayOnly,
 180   IN BOOLEAN         AllowShortcuts
 181   )
 182 {
 183   VENDOR_DEVICE_PATH  *Vendor;
 184   CHAR16              *Type;
 185   UINTN               Index;
 186   UINTN               DataLength;
 187   UINT32              FlowControlMap;
 188   UINT16              Info;
 189
 190   Vendor = (VENDOR_DEVICE_PATH *) DevPath;
 191   switch (DevicePathType (&Vendor->Header)) {
 192   case HARDWARE_DEVICE_PATH:
 193     Type = L"Hw";
 194     break;
 195
 196   case MESSAGING_DEVICE_PATH:
 197     Type = L"Msg";
 198     if (AllowShortcuts) {
 199       if (CompareGuid (&Vendor->Guid, &gEfiPcAnsiGuid)) {
 200         CatPrint (Str, L"VenPcAnsi()");
 201         return ;
 202       } else if (CompareGuid (&Vendor->Guid, &gEfiVT100Guid)) {
 203         CatPrint (Str, L"VenVt100()");
 204         return ;
 205       } else if (CompareGuid (&Vendor->Guid, &gEfiVT100PlusGuid)) {
 206         CatPrint (Str, L"VenVt100Plus()");
 207         return ;
 208       } else if (CompareGuid (&Vendor->Guid, &gEfiVTUTF8Guid)) {
 209         CatPrint (Str, L"VenUft8()");
 210         return ;
 211       } else if (CompareGuid (&Vendor->Guid, &gEfiUartDevicePathGuid)) {
 212         FlowControlMap = (((UART_FLOW_CONTROL_DEVICE_PATH *) Vendor)->FlowControlMap);
 213         switch (FlowControlMap & 0x00000003) {
 214         case 0:
 215           CatPrint (Str, L"UartFlowCtrl(%s)", L"None");
 216           break;
 217
 218         case 1:
 219           CatPrint (Str, L"UartFlowCtrl(%s)", L"Hardware");
 220           break;
 221
 222         case 2:
 223           CatPrint (Str, L"UartFlowCtrl(%s)", L"XonXoff");
 224           break;
 225
 226         default:
 227           break;
 228         }
 229
 230         return ;
 231       } else if (CompareGuid (&Vendor->Guid, &gEfiSasDevicePathGuid)) {
 232         CatPrint (
 233           Str,
 234           L"SAS(0x%lx,0x%lx,0x%x,",
 235           ((SAS_DEVICE_PATH *) Vendor)->SasAddress,
 236           ((SAS_DEVICE_PATH *) Vendor)->Lun,
 237           ((SAS_DEVICE_PATH *) Vendor)->RelativeTargetPort
 238           );
 239         Info = (((SAS_DEVICE_PATH *) Vendor)->DeviceTopology);
 240         if ((Info & 0x0f) == 0) {
 241           CatPrint (Str, L"NoTopology,0,0,0,");
 242         } else if (((Info & 0x0f) == 1) || ((Info & 0x0f) == 2)) {
 243           CatPrint (
 244             Str,
 245             L"%s,%s,%s,",
 246             ((Info & (0x1 << 4)) != 0) ? L"SATA" : L"SAS",
 247             ((Info & (0x1 << 5)) != 0) ? L"External" : L"Internal",
 248             ((Info & (0x1 << 6)) != 0) ? L"Expanded" : L"Direct"
 249             );
 250           if ((Info & 0x0f) == 1) {
 251             CatPrint (Str, L"0,");
 252           } else {
 253             CatPrint (Str, L"0x%x,", (Info >> 8) & 0xff);
 254           }
 255         } else {
 256           CatPrint (Str, L"0,0,0,0,");
 257         }
 258
 259         CatPrint (Str, L"0x%x)", ((SAS_DEVICE_PATH *) Vendor)->Reserved);
 260         return ;
 261       } else if (CompareGuid (&Vendor->Guid, &gEfiDebugPortProtocolGuid)) {
 262         CatPrint (Str, L"DebugPort()");
 263         return ;
 264       }
 265     }
 266     break;
 267
 268   case MEDIA_DEVICE_PATH:
 269     Type = L"Media";
 270     break;
 271
 272   default:
 273     Type = L"?";
 274     break;
 275   }
 276
 277   DataLength = DevicePathNodeLength (&Vendor->Header) - sizeof (VENDOR_DEVICE_PATH);
 278   CatPrint (Str, L"Ven%s(%g", Type, &Vendor->Guid);
 279   if (DataLength != 0) {
 280     CatPrint (Str, L",");
 281     for (Index = 0; Index < DataLength; Index++) {
 282       CatPrint (Str, L"%02x", ((VENDOR_DEVICE_PATH_WITH_DATA *) Vendor)->VendorDefinedData[Index]);
 283     }
 284   }
 285
 286   CatPrint (Str, L")");
 287 }
 288
 289 /**
 290   Converts a Controller device path structure to its string representative.
 291
 292   @param Str             The string representative of input device.
 293   @param DevPath         The input device path structure.
 294   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 295                          of the display node is used, where applicable. If DisplayOnly
 296                          is FALSE, then the longer text representation of the display node
 297                          is used.
 298   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 299                          representation for a device node can be used, where applicable.
 300
 301 **/
 302 VOID
 303 DevPathToTextController (
 304   IN OUT POOL_PRINT  *Str,
 305   IN VOID            *DevPath,
 306   IN BOOLEAN         DisplayOnly,
 307   IN BOOLEAN         AllowShortcuts
 308   )
 309 {
 310   CONTROLLER_DEVICE_PATH  *Controller;
 311
 312   Controller = DevPath;
 313   CatPrint (
 314     Str,
 315     L"Ctrl(0x%x)",
 316     Controller->ControllerNumber
 317     );
 318 }
 319
 320 /**
 321   Converts a ACPI device path structure to its string representative.
 322
 323   @param Str             The string representative of input device.
 324   @param DevPath         The input device path structure.
 325   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 326                          of the display node is used, where applicable. If DisplayOnly
 327                          is FALSE, then the longer text representation of the display node
 328                          is used.
 329   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 330                          representation for a device node can be used, where applicable.
 331
 332 **/
 333 VOID
 334 DevPathToTextAcpi (
 335   IN OUT POOL_PRINT  *Str,
 336   IN VOID            *DevPath,
 337   IN BOOLEAN         DisplayOnly,
 338   IN BOOLEAN         AllowShortcuts
 339   )
 340 {
 341   ACPI_HID_DEVICE_PATH  *Acpi;
 342
 343   Acpi = DevPath;
 344   if ((Acpi->HID & PNP_EISA_ID_MASK) == PNP_EISA_ID_CONST) {
 345     switch (EISA_ID_TO_NUM (Acpi->HID)) {
 346     case 0x0a03:
 347       CatPrint (Str, L"PciRoot(0x%x)", Acpi->UID);
 348       break;
 349
 350     case 0x0604:
 351       CatPrint (Str, L"Floppy(0x%x)", Acpi->UID);
 352       break;
 353
 354     case 0x0301:
 355       CatPrint (Str, L"Keyboard(0x%x)", Acpi->UID);
 356       break;
 357
 358     case 0x0501:
 359       CatPrint (Str, L"Serial(0x%x)", Acpi->UID);
 360       break;
 361
 362     case 0x0401:
 363       CatPrint (Str, L"ParallelPort(0x%x)", Acpi->UID);
 364       break;
 365
 366     default:
 367       CatPrint (Str, L"Acpi(PNP%04x,0x%x)", EISA_ID_TO_NUM (Acpi->HID), Acpi->UID);
 368       break;
 369     }
 370   } else {
 371     CatPrint (Str, L"Acpi(0x%08x,0x%x)", Acpi->HID, Acpi->UID);
 372   }
 373 }
 374
 375 /**
 376   Converts EISA identification to string.
 377
 378   @param EisaId        The input EISA identification.
 379   @param Text          A pointer to the output string.
 380
 381 **/
 382 VOID
 383 EisaIdToText (
 384   IN UINT32         EisaId,
 385   IN OUT CHAR16     *Text
 386   )
 387 {
 388   CHAR16 PnpIdStr[17];
 389
 390   //
 391   //UnicodeSPrint ("%X", 0x0a03) => "0000000000000A03"
 392   //
 393   UnicodeSPrint (PnpIdStr, 17 * 2, L"%16X", EisaId >> 16);
 394
 395   UnicodeSPrint (
 396     Text,
 397     sizeof (CHAR16) + sizeof (CHAR16) + sizeof (CHAR16) + sizeof (PnpIdStr),
 398     L"%c%c%c%s",
 399     '@' + ((EisaId >> 10) & 0x1f),
 400     '@' + ((EisaId >>  5) & 0x1f),
 401     '@' + ((EisaId >>  0) & 0x1f),
 402     PnpIdStr + (16 - 4)
 403     );
 404 }
 405
 406 /**
 407   Converts a ACPI extended HID device path structure to its string representative.
 408
 409   @param Str             The string representative of input device.
 410   @param DevPath         The input device path structure.
 411   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 412                          of the display node is used, where applicable. If DisplayOnly
 413                          is FALSE, then the longer text representation of the display node
 414                          is used.
 415   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 416                          representation for a device node can be used, where applicable.
 417
 418 **/
 419 VOID
 420 DevPathToTextAcpiEx (
 421   IN OUT POOL_PRINT  *Str,
 422   IN VOID            *DevPath,
 423   IN BOOLEAN         DisplayOnly,
 424   IN BOOLEAN         AllowShortcuts
 425   )
 426 {
 427   ACPI_EXTENDED_HID_DEVICE_PATH  *AcpiEx;
 428   CHAR8                          *HIDStr;
 429   CHAR8                          *UIDStr;
 430   CHAR8                          *CIDStr;
 431   CHAR16                         HIDText[11];
 432   CHAR16                         CIDText[11];
 433
 434   AcpiEx = DevPath;
 435   HIDStr = (CHAR8 *) (((UINT8 *) AcpiEx) + sizeof (ACPI_EXTENDED_HID_DEVICE_PATH));
 436   UIDStr = HIDStr + AsciiStrLen (HIDStr) + 1;
 437   CIDStr = UIDStr + AsciiStrLen (UIDStr) + 1;
 438
 439   EisaIdToText (AcpiEx->HID, HIDText);
 440   EisaIdToText (AcpiEx->CID, CIDText);
 441
 442   if ((*HIDStr == '\0') && (*CIDStr == '\0') && (AcpiEx->UID == 0)) {
 443     //
 444     // use AcpiExp()
 445     //
 446     CatPrint (
 447       Str,
 448       L"AcpiExp(%s,%s,%a)",
 449       HIDText,
 450       CIDText,
 451       UIDStr
 452       );
 453   } else {
 454     if (AllowShortcuts) {
 455       //
 456       // display only
 457       //
 458       if (AcpiEx->HID == 0) {
 459         CatPrint (Str, L"AcpiEx(%a,", HIDStr);
 460       } else {
 461         CatPrint (Str, L"AcpiEx(%s,", HIDText);
 462       }
 463
 464       if (AcpiEx->UID == 0) {
 465         CatPrint (Str, L"%a,", UIDStr);
 466       } else {
 467         CatPrint (Str, L"0x%x,", AcpiEx->UID);
 468       }
 469
 470       if (AcpiEx->CID == 0) {
 471         CatPrint (Str, L"%a)", CIDStr);
 472       } else {
 473         CatPrint (Str, L"%s)", CIDText);
 474       }
 475     } else {
 476       CatPrint (
 477         Str,
 478         L"AcpiEx(%s,%s,0x%x,%a,%a,%a)",
 479         HIDText,
 480         CIDText,
 481         AcpiEx->UID,
 482         HIDStr,
 483         CIDStr,
 484         UIDStr
 485         );
 486     }
 487   }
 488 }
 489
 490 /**
 491   Converts a ACPI address device path structure to its string representative.
 492
 493   @param Str             The string representative of input device.
 494   @param DevPath         The input device path structure.
 495   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 496                          of the display node is used, where applicable. If DisplayOnly
 497                          is FALSE, then the longer text representation of the display node
 498                          is used.
 499   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 500                          representation for a device node can be used, where applicable.
 501
 502 **/
 503 VOID
 504 DevPathToTextAcpiAdr (
 505   IN OUT POOL_PRINT  *Str,
 506   IN VOID            *DevPath,
 507   IN BOOLEAN         DisplayOnly,
 508   IN BOOLEAN         AllowShortcuts
 509   )
 510 {
 511   ACPI_ADR_DEVICE_PATH    *AcpiAdr;
 512   UINT16                  Index;
 513   UINT16                  Length;
 514   UINT16                  AdditionalAdrCount;
 515
 516   AcpiAdr            = DevPath;
 517   Length             = (UINT16) DevicePathNodeLength ((EFI_DEVICE_PATH_PROTOCOL *) AcpiAdr);
 518   AdditionalAdrCount = (UINT16) ((Length - 8) / 4);
 519
 520   CatPrint (Str, L"AcpiAdr(0x%x", AcpiAdr->ADR);
 521   for (Index = 0; Index < AdditionalAdrCount; Index++) {
 522     CatPrint (Str, L",0x%x", *(UINT32 *) ((UINT8 *) AcpiAdr + 8 + Index * 4));
 523   }
 524   CatPrint (Str, L")");
 525 }
 526
 527 /**
 528   Converts a ATAPI device path structure to its string representative.
 529
 530   @param Str             The string representative of input device.
 531   @param DevPath         The input device path structure.
 532   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 533                          of the display node is used, where applicable. If DisplayOnly
 534                          is FALSE, then the longer text representation of the display node
 535                          is used.
 536   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 537                          representation for a device node can be used, where applicable.
 538
 539 **/
 540 VOID
 541 DevPathToTextAtapi (
 542   IN OUT POOL_PRINT  *Str,
 543   IN VOID            *DevPath,
 544   IN BOOLEAN         DisplayOnly,
 545   IN BOOLEAN         AllowShortcuts
 546   )
 547 {
 548   ATAPI_DEVICE_PATH *Atapi;
 549
 550   Atapi = DevPath;
 551
 552   if (DisplayOnly) {
 553     CatPrint (Str, L"Ata(0x%x)", Atapi->Lun);
 554   } else {
 555     CatPrint (
 556       Str,
 557       L"Ata(%s,%s,0x%x)",
 558       Atapi->PrimarySecondary ? L"Secondary" : L"Primary",
 559       Atapi->SlaveMaster ? L"Slave" : L"Master",
 560       Atapi->Lun
 561       );
 562   }
 563 }
 564
 565 /**
 566   Converts a SCSI device path structure to its string representative.
 567
 568   @param Str             The string representative of input device.
 569   @param DevPath         The input device path structure.
 570   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 571                          of the display node is used, where applicable. If DisplayOnly
 572                          is FALSE, then the longer text representation of the display node
 573                          is used.
 574   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 575                          representation for a device node can be used, where applicable.
 576
 577 **/
 578 VOID
 579 DevPathToTextScsi (
 580   IN OUT POOL_PRINT  *Str,
 581   IN VOID            *DevPath,
 582   IN BOOLEAN         DisplayOnly,
 583   IN BOOLEAN         AllowShortcuts
 584   )
 585 {
 586   SCSI_DEVICE_PATH  *Scsi;
 587
 588   Scsi = DevPath;
 589   CatPrint (Str, L"Scsi(0x%x,0x%x)", Scsi->Pun, Scsi->Lun);
 590 }
 591
 592 /**
 593   Converts a Fibre device path structure to its string representative.
 594
 595   @param Str             The string representative of input device.
 596   @param DevPath         The input device path structure.
 597   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 598                          of the display node is used, where applicable. If DisplayOnly
 599                          is FALSE, then the longer text representation of the display node
 600                          is used.
 601   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 602                          representation for a device node can be used, where applicable.
 603
 604 **/
 605 VOID
 606 DevPathToTextFibre (
 607   IN OUT POOL_PRINT  *Str,
 608   IN VOID            *DevPath,
 609   IN BOOLEAN         DisplayOnly,
 610   IN BOOLEAN         AllowShortcuts
 611   )
 612 {
 613   FIBRECHANNEL_DEVICE_PATH  *Fibre;
 614
 615   Fibre = DevPath;
 616   CatPrint (Str, L"Fibre(0x%lx,0x%lx)", Fibre->WWN, Fibre->Lun);
 617 }
 618
 619 /**
 620   Converts a 1394 device path structure to its string representative.
 621
 622   @param Str             The string representative of input device.
 623   @param DevPath         The input device path structure.
 624   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 625                          of the display node is used, where applicable. If DisplayOnly
 626                          is FALSE, then the longer text representation of the display node
 627                          is used.
 628   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 629                          representation for a device node can be used, where applicable.
 630
 631 **/
 632 VOID
 633 DevPathToText1394 (
 634   IN OUT POOL_PRINT  *Str,
 635   IN VOID            *DevPath,
 636   IN BOOLEAN         DisplayOnly,
 637   IN BOOLEAN         AllowShortcuts
 638   )
 639 {
 640   F1394_DEVICE_PATH *F1394DevPath;
 641
 642   F1394DevPath = DevPath;
 643   //
 644   // Guid has format of IEEE-EUI64
 645   //
 646   CatPrint (Str, L"I1394(%016lx)", F1394DevPath->Guid);
 647 }
 648
 649 /**
 650   Converts a USB device path structure to its string representative.
 651
 652   @param Str             The string representative of input device.
 653   @param DevPath         The input device path structure.
 654   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 655                          of the display node is used, where applicable. If DisplayOnly
 656                          is FALSE, then the longer text representation of the display node
 657                          is used.
 658   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 659                          representation for a device node can be used, where applicable.
 660
 661 **/
 662 VOID
 663 DevPathToTextUsb (
 664   IN OUT POOL_PRINT  *Str,
 665   IN VOID            *DevPath,
 666   IN BOOLEAN         DisplayOnly,
 667   IN BOOLEAN         AllowShortcuts
 668   )
 669 {
 670   USB_DEVICE_PATH *Usb;
 671
 672   Usb = DevPath;
 673   CatPrint (Str, L"USB(0x%x,0x%x)", Usb->ParentPortNumber, Usb->InterfaceNumber);
 674 }
 675
 676 /**
 677   Converts a USB WWID device path structure to its string representative.
 678
 679   @param Str             The string representative of input device.
 680   @param DevPath         The input device path structure.
 681   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 682                          of the display node is used, where applicable. If DisplayOnly
 683                          is FALSE, then the longer text representation of the display node
 684                          is used.
 685   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 686                          representation for a device node can be used, where applicable.
 687
 688 **/
 689 VOID
 690 DevPathToTextUsbWWID (
 691   IN OUT POOL_PRINT  *Str,
 692   IN VOID            *DevPath,
 693   IN BOOLEAN         DisplayOnly,
 694   IN BOOLEAN         AllowShortcuts
 695   )
 696 {
 697   USB_WWID_DEVICE_PATH  *UsbWWId;
 698   CHAR16                *SerialNumberStr;
 699   CHAR16                *NewStr;
 700   UINT16                Length;
 701
 702   UsbWWId = DevPath;
 703
 704   SerialNumberStr = (CHAR16 *) ((UINT8 *) UsbWWId + sizeof (USB_WWID_DEVICE_PATH));
 705   Length = (UINT16) ((DevicePathNodeLength ((EFI_DEVICE_PATH_PROTOCOL *) UsbWWId) - sizeof (USB_WWID_DEVICE_PATH)) / sizeof (CHAR16));
 706   if (SerialNumberStr [Length - 1] != 0) {
 707     //
 708     // In case no NULL terminator in SerialNumber, create a new one with NULL terminator
 709     //
 710     NewStr = AllocateCopyPool ((Length + 1) * sizeof (CHAR16), SerialNumberStr);
 711     NewStr [Length] = 0;
 712     SerialNumberStr = NewStr;
 713   }
 714
 715   CatPrint (
 716     Str,
 717     L"UsbWwid(0x%x,0x%x,0x%x,\"%s\")",
 718     UsbWWId->VendorId,
 719     UsbWWId->ProductId,
 720     UsbWWId->InterfaceNumber,
 721     SerialNumberStr
 722     );
 723 }
 724
 725 /**
 726   Converts a Logic Unit device path structure to its string representative.
 727
 728   @param Str             The string representative of input device.
 729   @param DevPath         The input device path structure.
 730   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 731                          of the display node is used, where applicable. If DisplayOnly
 732                          is FALSE, then the longer text representation of the display node
 733                          is used.
 734   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 735                          representation for a device node can be used, where applicable.
 736
 737 **/
 738 VOID
 739 DevPathToTextLogicalUnit (
 740   IN OUT POOL_PRINT  *Str,
 741   IN VOID            *DevPath,
 742   IN BOOLEAN         DisplayOnly,
 743   IN BOOLEAN         AllowShortcuts
 744   )
 745 {
 746   DEVICE_LOGICAL_UNIT_DEVICE_PATH *LogicalUnit;
 747
 748   LogicalUnit = DevPath;
 749   CatPrint (Str, L"Unit(0x%x)", LogicalUnit->Lun);
 750 }
 751
 752 /**
 753   Converts a USB class device path structure to its string representative.
 754
 755   @param Str             The string representative of input device.
 756   @param DevPath         The input device path structure.
 757   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 758                          of the display node is used, where applicable. If DisplayOnly
 759                          is FALSE, then the longer text representation of the display node
 760                          is used.
 761   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 762                          representation for a device node can be used, where applicable.
 763
 764 **/
 765 VOID
 766 DevPathToTextUsbClass (
 767   IN OUT POOL_PRINT  *Str,
 768   IN VOID            *DevPath,
 769   IN BOOLEAN         DisplayOnly,
 770   IN BOOLEAN         AllowShortcuts
 771   )
 772 {
 773   USB_CLASS_DEVICE_PATH *UsbClass;
 774   BOOLEAN               IsKnownSubClass;
 775
 776
 777   UsbClass = DevPath;
 778
 779   IsKnownSubClass = TRUE;
 780   switch (UsbClass->DeviceClass) {
 781   case USB_CLASS_AUDIO:
 782     CatPrint (Str, L"UsbAudio");
 783     break;
 784
 785   case USB_CLASS_CDCCONTROL:
 786     CatPrint (Str, L"UsbCDCControl");
 787     break;
 788
 789   case USB_CLASS_HID:
 790     CatPrint (Str, L"UsbHID");
 791     break;
 792
 793   case USB_CLASS_IMAGE:
 794     CatPrint (Str, L"UsbImage");
 795     break;
 796
 797   case USB_CLASS_PRINTER:
 798     CatPrint (Str, L"UsbPrinter");
 799     break;
 800
 801   case USB_CLASS_MASS_STORAGE:
 802     CatPrint (Str, L"UsbMassStorage");
 803     break;
 804
 805   case USB_CLASS_HUB:
 806     CatPrint (Str, L"UsbHub");
 807     break;
 808
 809   case USB_CLASS_CDCDATA:
 810     CatPrint (Str, L"UsbCDCData");
 811     break;
 812
 813   case USB_CLASS_SMART_CARD:
 814     CatPrint (Str, L"UsbSmartCard");
 815     break;
 816
 817   case USB_CLASS_VIDEO:
 818     CatPrint (Str, L"UsbVideo");
 819     break;
 820
 821   case USB_CLASS_DIAGNOSTIC:
 822     CatPrint (Str, L"UsbDiagnostic");
 823     break;
 824
 825   case USB_CLASS_WIRELESS:
 826     CatPrint (Str, L"UsbWireless");
 827     break;
 828
 829   default:
 830     IsKnownSubClass = FALSE;
 831     break;
 832   }
 833
 834   if (IsKnownSubClass) {
 835     CatPrint (
 836       Str,
 837       L"(0x%x,0x%x,0x%x,0x%x)",
 838       UsbClass->VendorId,
 839       UsbClass->ProductId,
 840       UsbClass->DeviceSubClass,
 841       UsbClass->DeviceProtocol
 842       );
 843     return;
 844   }
 845
 846   if (UsbClass->DeviceClass == USB_CLASS_RESERVE) {
 847     if (UsbClass->DeviceSubClass == USB_SUBCLASS_FW_UPDATE) {
 848       CatPrint (
 849         Str,
 850         L"UsbDeviceFirmwareUpdate(0x%x,0x%x,0x%x)",
 851         UsbClass->VendorId,
 852         UsbClass->ProductId,
 853         UsbClass->DeviceProtocol
 854         );
 855       return;
 856     } else if (UsbClass->DeviceSubClass == USB_SUBCLASS_IRDA_BRIDGE) {
 857       CatPrint (
 858         Str,
 859         L"UsbIrdaBridge(0x%x,0x%x,0x%x)",
 860         UsbClass->VendorId,
 861         UsbClass->ProductId,
 862         UsbClass->DeviceProtocol
 863         );
 864       return;
 865     } else if (UsbClass->DeviceSubClass == USB_SUBCLASS_TEST) {
 866       CatPrint (
 867         Str,
 868         L"UsbTestAndMeasurement(0x%x,0x%x,0x%x)",
 869         UsbClass->VendorId,
 870         UsbClass->ProductId,
 871         UsbClass->DeviceProtocol
 872         );
 873       return;
 874     }
 875   }
 876
 877   CatPrint (
 878     Str,
 879     L"UsbClass(0x%x,0x%x,0x%x,0x%x,0x%x)",
 880     UsbClass->VendorId,
 881     UsbClass->ProductId,
 882     UsbClass->DeviceClass,
 883     UsbClass->DeviceSubClass,
 884     UsbClass->DeviceProtocol
 885     );
 886 }
 887
 888 /**
 889   Converts a SATA device path structure to its string representative.
 890
 891   @param Str             The string representative of input device.
 892   @param DevPath         The input device path structure.
 893   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 894                          of the display node is used, where applicable. If DisplayOnly
 895                          is FALSE, then the longer text representation of the display node
 896                          is used.
 897   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 898                          representation for a device node can be used, where applicable.
 899
 900 **/
 901 VOID
 902 DevPathToTextSata (
 903   IN OUT POOL_PRINT  *Str,
 904   IN VOID            *DevPath,
 905   IN BOOLEAN         DisplayOnly,
 906   IN BOOLEAN         AllowShortcuts
 907   )
 908 {
 909   SATA_DEVICE_PATH *Sata;
 910
 911   Sata = DevPath;
 912   CatPrint (
 913     Str,
 914     L"Sata(0x%x,0x%x,0x%x)",
 915     (UINTN) Sata->HBAPortNumber,
 916     (UINTN) Sata->PortMultiplierPortNumber,
 917     (UINTN) Sata->Lun
 918     );
 919 }
 920
 921 /**
 922   Converts a I20 device path structure to its string representative.
 923
 924   @param Str             The string representative of input device.
 925   @param DevPath         The input device path structure.
 926   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 927                          of the display node is used, where applicable. If DisplayOnly
 928                          is FALSE, then the longer text representation of the display node
 929                          is used.
 930   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 931                          representation for a device node can be used, where applicable.
 932
 933 **/
 934 VOID
 935 DevPathToTextI2O (
 936   IN OUT POOL_PRINT  *Str,
 937   IN VOID            *DevPath,
 938   IN BOOLEAN         DisplayOnly,
 939   IN BOOLEAN         AllowShortcuts
 940   )
 941 {
 942   I2O_DEVICE_PATH *I2ODevPath;
 943
 944   I2ODevPath = DevPath;
 945   CatPrint (Str, L"I2O(0x%x)", I2ODevPath->Tid);
 946 }
 947
 948 /**
 949   Converts a MAC address device path structure to its string representative.
 950
 951   @param Str             The string representative of input device.
 952   @param DevPath         The input device path structure.
 953   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 954                          of the display node is used, where applicable. If DisplayOnly
 955                          is FALSE, then the longer text representation of the display node
 956                          is used.
 957   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 958                          representation for a device node can be used, where applicable.
 959
 960 **/
 961 VOID
 962 DevPathToTextMacAddr (
 963   IN OUT POOL_PRINT  *Str,
 964   IN VOID            *DevPath,
 965   IN BOOLEAN         DisplayOnly,
 966   IN BOOLEAN         AllowShortcuts
 967   )
 968 {
 969   MAC_ADDR_DEVICE_PATH  *MacDevPath;
 970   UINTN                 HwAddressSize;
 971   UINTN                 Index;
 972
 973   MacDevPath = DevPath;
 974
 975   HwAddressSize = sizeof (EFI_MAC_ADDRESS);
 976   if (MacDevPath->IfType == 0x01 || MacDevPath->IfType == 0x00) {
 977     HwAddressSize = 6;
 978   }
 979
 980   CatPrint (Str, L"MAC(");
 981
 982   for (Index = 0; Index < HwAddressSize; Index++) {
 983     CatPrint (Str, L"%02x", MacDevPath->MacAddress.Addr[Index]);
 984   }
 985
 986   CatPrint (Str, L",0x%x)", MacDevPath->IfType);
 987 }
 988
 989 /**
 990   Converts a IPv4 device path structure to its string representative.
 991
 992   @param Str             The string representative of input device.
 993   @param DevPath         The input device path structure.
 994   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 995                          of the display node is used, where applicable. If DisplayOnly
 996                          is FALSE, then the longer text representation of the display node
 997                          is used.
 998   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 999                          representation for a device node can be used, where applicable.
1000
1001 **/
1002 VOID
1003 DevPathToTextIPv4 (
1004   IN OUT POOL_PRINT  *Str,
1005   IN VOID            *DevPath,
1006   IN BOOLEAN         DisplayOnly,
1007   IN BOOLEAN         AllowShortcuts
1008   )
1009 {
1010   IPv4_DEVICE_PATH  *IPDevPath;
1011
1012   IPDevPath = DevPath;
1013   if (DisplayOnly) {
1014     CatPrint (
1015       Str,
1016       L"IPv4(%d.%d.%d.%d)",
1017       IPDevPath->RemoteIpAddress.Addr[0],
1018       IPDevPath->RemoteIpAddress.Addr[1],
1019       IPDevPath->RemoteIpAddress.Addr[2],
1020       IPDevPath->RemoteIpAddress.Addr[3]
1021       );
1022     return ;
1023   }
1024
1025   CatPrint (
1026     Str,
1027     L"IPv4(%d.%d.%d.%d,%s,%s,%d.%d.%d.%d)",
1028     IPDevPath->RemoteIpAddress.Addr[0],
1029     IPDevPath->RemoteIpAddress.Addr[1],
1030     IPDevPath->RemoteIpAddress.Addr[2],
1031     IPDevPath->RemoteIpAddress.Addr[3],
1032     IPDevPath->Protocol ? L"TCP" : L"UDP",
1033     (IPDevPath->StaticIpAddress == TRUE) ? L"Static" : L"DHCP",
1034     IPDevPath->LocalIpAddress.Addr[0],
1035     IPDevPath->LocalIpAddress.Addr[1],
1036     IPDevPath->LocalIpAddress.Addr[2],
1037     IPDevPath->LocalIpAddress.Addr[3]
1038     );
1039 }
1040
1041 /**
1042   Converts a IPv6 device path structure to its string representative.
1043
1044   @param Str             The string representative of input device.
1045   @param DevPath         The input device path structure.
1046   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1047                          of the display node is used, where applicable. If DisplayOnly
1048                          is FALSE, then the longer text representation of the display node
1049                          is used.
1050   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1051                          representation for a device node can be used, where applicable.
1052
1053 **/
1054 VOID
1055 DevPathToTextIPv6 (
1056   IN OUT POOL_PRINT  *Str,
1057   IN VOID            *DevPath,
1058   IN BOOLEAN         DisplayOnly,
1059   IN BOOLEAN         AllowShortcuts
1060   )
1061 {
1062   IPv6_DEVICE_PATH  *IPDevPath;
1063
1064   IPDevPath = DevPath;
1065   if (DisplayOnly) {
1066     CatPrint (
1067       Str,
1068       L"IPv6(%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x)",
1069       IPDevPath->RemoteIpAddress.Addr[0],
1070       IPDevPath->RemoteIpAddress.Addr[1],
1071       IPDevPath->RemoteIpAddress.Addr[2],
1072       IPDevPath->RemoteIpAddress.Addr[3],
1073       IPDevPath->RemoteIpAddress.Addr[4],
1074       IPDevPath->RemoteIpAddress.Addr[5],
1075       IPDevPath->RemoteIpAddress.Addr[6],
1076       IPDevPath->RemoteIpAddress.Addr[7],
1077       IPDevPath->RemoteIpAddress.Addr[8],
1078       IPDevPath->RemoteIpAddress.Addr[9],
1079       IPDevPath->RemoteIpAddress.Addr[10],
1080       IPDevPath->RemoteIpAddress.Addr[11],
1081       IPDevPath->RemoteIpAddress.Addr[12],
1082       IPDevPath->RemoteIpAddress.Addr[13],
1083       IPDevPath->RemoteIpAddress.Addr[14],
1084       IPDevPath->RemoteIpAddress.Addr[15]
1085       );
1086     return ;
1087   }
1088
1089   CatPrint (
1090     Str,
1091     L"IPv6(%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x,%s,%s,%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x)",
1092     IPDevPath->RemoteIpAddress.Addr[0],
1093     IPDevPath->RemoteIpAddress.Addr[1],
1094     IPDevPath->RemoteIpAddress.Addr[2],
1095     IPDevPath->RemoteIpAddress.Addr[3],
1096     IPDevPath->RemoteIpAddress.Addr[4],
1097     IPDevPath->RemoteIpAddress.Addr[5],
1098     IPDevPath->RemoteIpAddress.Addr[6],
1099     IPDevPath->RemoteIpAddress.Addr[7],
1100     IPDevPath->RemoteIpAddress.Addr[8],
1101     IPDevPath->RemoteIpAddress.Addr[9],
1102     IPDevPath->RemoteIpAddress.Addr[10],
1103     IPDevPath->RemoteIpAddress.Addr[11],
1104     IPDevPath->RemoteIpAddress.Addr[12],
1105     IPDevPath->RemoteIpAddress.Addr[13],
1106     IPDevPath->RemoteIpAddress.Addr[14],
1107     IPDevPath->RemoteIpAddress.Addr[15],
1108     IPDevPath->Protocol ? L"TCP" : L"UDP",
1109     (IPDevPath->StaticIpAddress == TRUE) ? L"Static" : L"DHCP",
1110     IPDevPath->LocalIpAddress.Addr[0],
1111     IPDevPath->LocalIpAddress.Addr[1],
1112     IPDevPath->LocalIpAddress.Addr[2],
1113     IPDevPath->LocalIpAddress.Addr[3],
1114     IPDevPath->LocalIpAddress.Addr[4],
1115     IPDevPath->LocalIpAddress.Addr[5],
1116     IPDevPath->LocalIpAddress.Addr[6],
1117     IPDevPath->LocalIpAddress.Addr[7],
1118     IPDevPath->LocalIpAddress.Addr[8],
1119     IPDevPath->LocalIpAddress.Addr[9],
1120     IPDevPath->LocalIpAddress.Addr[10],
1121     IPDevPath->LocalIpAddress.Addr[11],
1122     IPDevPath->LocalIpAddress.Addr[12],
1123     IPDevPath->LocalIpAddress.Addr[13],
1124     IPDevPath->LocalIpAddress.Addr[14],
1125     IPDevPath->LocalIpAddress.Addr[15]
1126     );
1127 }
1128
1129 /**
1130   Converts an Infini Band device path structure to its string representative.
1131
1132   @param Str             The string representative of input device.
1133   @param DevPath         The input device path structure.
1134   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1135                          of the display node is used, where applicable. If DisplayOnly
1136                          is FALSE, then the longer text representation of the display node
1137                          is used.
1138   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1139                          representation for a device node can be used, where applicable.
1140
1141 **/
1142 VOID
1143 DevPathToTextInfiniBand (
1144   IN OUT POOL_PRINT  *Str,
1145   IN VOID            *DevPath,
1146   IN BOOLEAN         DisplayOnly,
1147   IN BOOLEAN         AllowShortcuts
1148   )
1149 {
1150   INFINIBAND_DEVICE_PATH  *InfiniBand;
1151
1152   InfiniBand = DevPath;
1153   CatPrint (
1154     Str,
1155     L"Infiniband(0x%x,%g,0x%lx,0x%lx,0x%lx)",
1156     InfiniBand->ResourceFlags,
1157     InfiniBand->PortGid,
1158     InfiniBand->ServiceId,
1159     InfiniBand->TargetPortId,
1160     InfiniBand->DeviceId
1161     );
1162 }
1163
1164 /**
1165   Converts a UART device path structure to its string representative.
1166
1167   @param Str             The string representative of input device.
1168   @param DevPath         The input device path structure.
1169   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1170                          of the display node is used, where applicable. If DisplayOnly
1171                          is FALSE, then the longer text representation of the display node
1172                          is used.
1173   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1174                          representation for a device node can be used, where applicable.
1175
1176 **/
1177 VOID
1178 DevPathToTextUart (
1179   IN OUT POOL_PRINT  *Str,
1180   IN VOID            *DevPath,
1181   IN BOOLEAN         DisplayOnly,
1182   IN BOOLEAN         AllowShortcuts
1183   )
1184 {
1185   UART_DEVICE_PATH  *Uart;
1186   CHAR8             Parity;
1187
1188   Uart = DevPath;
1189   switch (Uart->Parity) {
1190   case 0:
1191     Parity = 'D';
1192     break;
1193
1194   case 1:
1195     Parity = 'N';
1196     break;
1197
1198   case 2:
1199     Parity = 'E';
1200     break;
1201
1202   case 3:
1203     Parity = 'O';
1204     break;
1205
1206   case 4:
1207     Parity = 'M';
1208     break;
1209
1210   case 5:
1211     Parity = 'S';
1212     break;
1213
1214   default:
1215     Parity = 'x';
1216     break;
1217   }
1218
1219   if (Uart->BaudRate == 0) {
1220     CatPrint (Str, L"Uart(DEFAULT,");
1221   } else {
1222     CatPrint (Str, L"Uart(%ld,", Uart->BaudRate);
1223   }
1224
1225   if (Uart->DataBits == 0) {
1226     CatPrint (Str, L"DEFAULT,");
1227   } else {
1228     CatPrint (Str, L"%d,", Uart->DataBits);
1229   }
1230
1231   CatPrint (Str, L"%c,", Parity);
1232
1233   switch (Uart->StopBits) {
1234   case 0:
1235     CatPrint (Str, L"D)");
1236     break;
1237
1238   case 1:
1239     CatPrint (Str, L"1)");
1240     break;
1241
1242   case 2:
1243     CatPrint (Str, L"1.5)");
1244     break;
1245
1246   case 3:
1247     CatPrint (Str, L"2)");
1248     break;
1249
1250   default:
1251     CatPrint (Str, L"x)");
1252     break;
1253   }
1254 }
1255
1256 /**
1257   Converts an iSCSI device path structure to its string representative.
1258
1259   @param Str             The string representative of input device.
1260   @param DevPath         The input device path structure.
1261   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1262                          of the display node is used, where applicable. If DisplayOnly
1263                          is FALSE, then the longer text representation of the display node
1264                          is used.
1265   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1266                          representation for a device node can be used, where applicable.
1267
1268 **/
1269 VOID
1270 DevPathToTextiSCSI (
1271   IN OUT POOL_PRINT  *Str,
1272   IN VOID            *DevPath,
1273   IN BOOLEAN         DisplayOnly,
1274   IN BOOLEAN         AllowShortcuts
1275   )
1276 {
1277   ISCSI_DEVICE_PATH_WITH_NAME *ISCSIDevPath;
1278   UINT16                      Options;
1279
1280   ISCSIDevPath = DevPath;
1281   CatPrint (
1282     Str,
1283     L"iSCSI(%a,0x%x,0x%lx,",
1284     ISCSIDevPath->iSCSITargetName,
1285     ISCSIDevPath->TargetPortalGroupTag,
1286     ISCSIDevPath->Lun
1287     );
1288
1289   Options = ISCSIDevPath->LoginOption;
1290   CatPrint (Str, L"%s,", (((Options >> 1) & 0x0001) != 0) ? L"CRC32C" : L"None");
1291   CatPrint (Str, L"%s,", (((Options >> 3) & 0x0001) != 0) ? L"CRC32C" : L"None");
1292   if (((Options >> 11) & 0x0001) != 0) {
1293     CatPrint (Str, L"%s,", L"None");
1294   } else if (((Options >> 12) & 0x0001) != 0) {
1295     CatPrint (Str, L"%s,", L"CHAP_UNI");
1296   } else {
1297     CatPrint (Str, L"%s,", L"CHAP_BI");
1298
1299   }
1300
1301   CatPrint (Str, L"%s)", (ISCSIDevPath->NetworkProtocol == 0) ? L"TCP" : L"reserved");
1302 }
1303
1304 /**
1305   Converts a Hard drive device path structure to its string representative.
1306
1307   @param Str             The string representative of input device.
1308   @param DevPath         The input device path structure.
1309   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1310                          of the display node is used, where applicable. If DisplayOnly
1311                          is FALSE, then the longer text representation of the display node
1312                          is used.
1313   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1314                          representation for a device node can be used, where applicable.
1315
1316 **/
1317 VOID
1318 DevPathToTextHardDrive (
1319   IN OUT POOL_PRINT  *Str,
1320   IN VOID            *DevPath,
1321   IN BOOLEAN         DisplayOnly,
1322   IN BOOLEAN         AllowShortcuts
1323   )
1324 {
1325   HARDDRIVE_DEVICE_PATH *Hd;
1326
1327   Hd = DevPath;
1328   switch (Hd->SignatureType) {
1329   case SIGNATURE_TYPE_MBR:
1330     CatPrint (
1331       Str,
1332       L"HD(%d,%s,0x%08x,",
1333       Hd->PartitionNumber,
1334       L"MBR",
1335       *((UINT32 *) (&(Hd->Signature[0])))
1336       );
1337     break;
1338
1339   case SIGNATURE_TYPE_GUID:
1340     CatPrint (
1341       Str,
1342       L"HD(%d,%s,%g,",
1343       Hd->PartitionNumber,
1344       L"GPT",
1345       (EFI_GUID *) &(Hd->Signature[0])
1346       );
1347     break;
1348
1349   default:
1350     CatPrint (
1351       Str,
1352       L"HD(%d,%d,0,",
1353       Hd->PartitionNumber,
1354       Hd->SignatureType
1355       );
1356     break;
1357   }
1358
1359   CatPrint (Str, L"0x%lx,0x%lx)", Hd->PartitionStart, Hd->PartitionSize);
1360 }
1361
1362 /**
1363   Converts a CDROM device path structure to its string representative.
1364
1365   @param Str             The string representative of input device.
1366   @param DevPath         The input device path structure.
1367   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1368                          of the display node is used, where applicable. If DisplayOnly
1369                          is FALSE, then the longer text representation of the display node
1370                          is used.
1371   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1372                          representation for a device node can be used, where applicable.
1373
1374 **/
1375 VOID
1376 DevPathToTextCDROM (
1377   IN OUT POOL_PRINT  *Str,
1378   IN VOID            *DevPath,
1379   IN BOOLEAN         DisplayOnly,
1380   IN BOOLEAN         AllowShortcuts
1381   )
1382 {
1383   CDROM_DEVICE_PATH *Cd;
1384
1385   Cd = DevPath;
1386   if (DisplayOnly) {
1387     CatPrint (Str, L"CDROM(0x%x)", Cd->BootEntry);
1388     return ;
1389   }
1390
1391   CatPrint (Str, L"CDROM(0x%x,0x%lx,0x%lx)", Cd->BootEntry, Cd->PartitionStart, Cd->PartitionSize);
1392 }
1393
1394 /**
1395   Converts a File device path structure to its string representative.
1396
1397   @param Str             The string representative of input device.
1398   @param DevPath         The input device path structure.
1399   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1400                          of the display node is used, where applicable. If DisplayOnly
1401                          is FALSE, then the longer text representation of the display node
1402                          is used.
1403   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1404                          representation for a device node can be used, where applicable.
1405
1406 **/
1407 VOID
1408 DevPathToTextFilePath (
1409   IN OUT POOL_PRINT  *Str,
1410   IN VOID            *DevPath,
1411   IN BOOLEAN         DisplayOnly,
1412   IN BOOLEAN         AllowShortcuts
1413   )
1414 {
1415   FILEPATH_DEVICE_PATH  *Fp;
1416
1417   Fp = DevPath;
1418   CatPrint (Str, L"%s", Fp->PathName);
1419 }
1420
1421 /**
1422   Converts a Media protocol device path structure to its string representative.
1423
1424   @param Str             The string representative of input device.
1425   @param DevPath         The input device path structure.
1426   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1427                          of the display node is used, where applicable. If DisplayOnly
1428                          is FALSE, then the longer text representation of the display node
1429                          is used.
1430   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1431                          representation for a device node can be used, where applicable.
1432
1433 **/
1434 VOID
1435 DevPathToTextMediaProtocol (
1436   IN OUT POOL_PRINT  *Str,
1437   IN VOID            *DevPath,
1438   IN BOOLEAN         DisplayOnly,
1439   IN BOOLEAN         AllowShortcuts
1440   )
1441 {
1442   MEDIA_PROTOCOL_DEVICE_PATH  *MediaProt;
1443
1444   MediaProt = DevPath;
1445   CatPrint (Str, L"Media(%g)", &MediaProt->Protocol);
1446 }
1447
1448 /**
1449   Converts a Firmware Volume device path structure to its string representative.
1450
1451   @param Str             The string representative of input device.
1452   @param DevPath         The input device path structure.
1453   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1454                          of the display node is used, where applicable. If DisplayOnly
1455                          is FALSE, then the longer text representation of the display node
1456                          is used.
1457   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1458                          representation for a device node can be used, where applicable.
1459
1460 **/
1461 VOID
1462 DevPathToTextFv (
1463   IN OUT POOL_PRINT  *Str,
1464   IN VOID            *DevPath,
1465   IN BOOLEAN         DisplayOnly,
1466   IN BOOLEAN         AllowShortcuts
1467   )
1468 {
1469   MEDIA_FW_VOL_DEVICE_PATH  *Fv;
1470
1471   Fv = DevPath;
1472   CatPrint (Str, L"Fv(%g)", &Fv->FvName);
1473 }
1474
1475 /**
1476   Converts a Firmware Volume File device path structure to its string representative.
1477
1478   @param Str             The string representative of input device.
1479   @param DevPath         The input device path structure.
1480   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1481                          of the display node is used, where applicable. If DisplayOnly
1482                          is FALSE, then the longer text representation of the display node
1483                          is used.
1484   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1485                          representation for a device node can be used, where applicable.
1486
1487 **/
1488 VOID
1489 DevPathToTextFvFile (
1490   IN OUT POOL_PRINT  *Str,
1491   IN VOID            *DevPath,
1492   IN BOOLEAN         DisplayOnly,
1493   IN BOOLEAN         AllowShortcuts
1494   )
1495 {
1496   MEDIA_FW_VOL_FILEPATH_DEVICE_PATH  *FvFile;
1497
1498   FvFile = DevPath;
1499   CatPrint (Str, L"FvFile(%g)", &FvFile->FvFileName);
1500 }
1501
1502 /**
1503   Converts a BIOS Boot Specification device path structure to its string representative.
1504
1505   @param Str             The string representative of input device.
1506   @param DevPath         The input device path structure.
1507   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1508                          of the display node is used, where applicable. If DisplayOnly
1509                          is FALSE, then the longer text representation of the display node
1510                          is used.
1511   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1512                          representation for a device node can be used, where applicable.
1513
1514 **/
1515 VOID
1516 DevPathToTextBBS (
1517   IN OUT POOL_PRINT  *Str,
1518   IN VOID            *DevPath,
1519   IN BOOLEAN         DisplayOnly,
1520   IN BOOLEAN         AllowShortcuts
1521   )
1522 {
1523   BBS_BBS_DEVICE_PATH *Bbs;
1524   CHAR16              *Type;
1525
1526   Bbs = DevPath;
1527   switch (Bbs->DeviceType) {
1528   case BBS_TYPE_FLOPPY:
1529     Type = L"Floppy";
1530     break;
1531
1532   case BBS_TYPE_HARDDRIVE:
1533     Type = L"HD";
1534     break;
1535
1536   case BBS_TYPE_CDROM:
1537     Type = L"CDROM";
1538     break;
1539
1540   case BBS_TYPE_PCMCIA:
1541     Type = L"PCMCIA";
1542     break;
1543
1544   case BBS_TYPE_USB:
1545     Type = L"USB";
1546     break;
1547
1548   case BBS_TYPE_EMBEDDED_NETWORK:
1549     Type = L"Network";
1550     break;
1551
1552   default:
1553     Type = NULL;
1554     break;
1555   }
1556
1557   if (Type != NULL) {
1558     CatPrint (Str, L"BBS(%s,%a", Type, Bbs->String);
1559   } else {
1560     CatPrint (Str, L"BBS(0x%x,%a", Bbs->DeviceType, Bbs->String);
1561   }
1562
1563   if (DisplayOnly) {
1564     CatPrint (Str, L")");
1565     return ;
1566   }
1567
1568   CatPrint (Str, L",0x%x)", Bbs->StatusFlag);
1569 }
1570
1571 /**
1572   Converts an End-of-Device-Path structure to its string representative.
1573
1574   @param Str             The string representative of input device.
1575   @param DevPath         The input device path structure.
1576   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1577                          of the display node is used, where applicable. If DisplayOnly
1578                          is FALSE, then the longer text representation of the display node
1579                          is used.
1580   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1581                          representation for a device node can be used, where applicable.
1582
1583 **/
1584 VOID
1585 DevPathToTextEndInstance (
1586   IN OUT POOL_PRINT  *Str,
1587   IN VOID            *DevPath,
1588   IN BOOLEAN         DisplayOnly,
1589   IN BOOLEAN         AllowShortcuts
1590   )
1591 {
1592   CatPrint (Str, L",");
1593 }
1594
1595 /**
1596   Converts an unknown device path structure to its string representative.
1597
1598   @param Str             The string representative of input device.
1599   @param DevPath         The input device path structure.
1600   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1601                          of the display node is used, where applicable. If DisplayOnly
1602                          is FALSE, then the longer text representation of the display node
1603                          is used.
1604   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1605                          representation for a device node can be used, where applicable.
1606
1607 **/
1608 VOID
1609 DevPathToTextNodeUnknown (
1610   IN OUT POOL_PRINT  *Str,
1611   IN VOID            *DevPath,
1612   IN BOOLEAN         DisplayOnly,
1613   IN BOOLEAN         AllowShortcuts
1614   )
1615 {
1616   CatPrint (Str, L"?");
1617 }
1618
1619 GLOBAL_REMOVE_IF_UNREFERENCED const DEVICE_PATH_TO_TEXT_TABLE DevPathToTextTable[] = {
1620   {HARDWARE_DEVICE_PATH, HW_PCI_DP, DevPathToTextPci},
1621   {HARDWARE_DEVICE_PATH, HW_PCCARD_DP, DevPathToTextPccard},
1622   {HARDWARE_DEVICE_PATH, HW_MEMMAP_DP, DevPathToTextMemMap},
1623   {HARDWARE_DEVICE_PATH, HW_VENDOR_DP, DevPathToTextVendor},
1624   {HARDWARE_DEVICE_PATH, HW_CONTROLLER_DP, DevPathToTextController},
1625   {ACPI_DEVICE_PATH, ACPI_DP, DevPathToTextAcpi},
1626   {ACPI_DEVICE_PATH, ACPI_EXTENDED_DP, DevPathToTextAcpiEx},
1627   {ACPI_DEVICE_PATH, ACPI_ADR_DP, DevPathToTextAcpiAdr},
1628   {MESSAGING_DEVICE_PATH, MSG_ATAPI_DP, DevPathToTextAtapi},
1629   {MESSAGING_DEVICE_PATH, MSG_SCSI_DP, DevPathToTextScsi},
1630   {MESSAGING_DEVICE_PATH, MSG_FIBRECHANNEL_DP, DevPathToTextFibre},
1631   {MESSAGING_DEVICE_PATH, MSG_1394_DP, DevPathToText1394},
1632   {MESSAGING_DEVICE_PATH, MSG_USB_DP, DevPathToTextUsb},
1633   {MESSAGING_DEVICE_PATH, MSG_USB_WWID_DP, DevPathToTextUsbWWID},
1634   {MESSAGING_DEVICE_PATH, MSG_DEVICE_LOGICAL_UNIT_DP, DevPathToTextLogicalUnit},
1635   {MESSAGING_DEVICE_PATH, MSG_USB_CLASS_DP, DevPathToTextUsbClass},
1636   {MESSAGING_DEVICE_PATH, MSG_SATA_DP, DevPathToTextSata},
1637   {MESSAGING_DEVICE_PATH, MSG_I2O_DP, DevPathToTextI2O},
1638   {MESSAGING_DEVICE_PATH, MSG_MAC_ADDR_DP, DevPathToTextMacAddr},
1639   {MESSAGING_DEVICE_PATH, MSG_IPv4_DP, DevPathToTextIPv4},
1640   {MESSAGING_DEVICE_PATH, MSG_IPv6_DP, DevPathToTextIPv6},
1641   {MESSAGING_DEVICE_PATH, MSG_INFINIBAND_DP, DevPathToTextInfiniBand},
1642   {MESSAGING_DEVICE_PATH, MSG_UART_DP, DevPathToTextUart},
1643   {MESSAGING_DEVICE_PATH, MSG_VENDOR_DP, DevPathToTextVendor},
1644   {MESSAGING_DEVICE_PATH, MSG_ISCSI_DP, DevPathToTextiSCSI},
1645   {MEDIA_DEVICE_PATH, MEDIA_HARDDRIVE_DP, DevPathToTextHardDrive},
1646   {MEDIA_DEVICE_PATH, MEDIA_CDROM_DP, DevPathToTextCDROM},
1647   {MEDIA_DEVICE_PATH, MEDIA_VENDOR_DP, DevPathToTextVendor},
1648   {MEDIA_DEVICE_PATH, MEDIA_FILEPATH_DP, DevPathToTextFilePath},
1649   {MEDIA_DEVICE_PATH, MEDIA_PROTOCOL_DP, DevPathToTextMediaProtocol},
1650   {MEDIA_DEVICE_PATH, MEDIA_FILEPATH_DP, DevPathToTextFilePath},
1651   {MEDIA_DEVICE_PATH, MEDIA_PIWG_FW_VOL_DP, DevPathToTextFv},
1652   {MEDIA_DEVICE_PATH, MEDIA_PIWG_FW_FILE_DP, DevPathToTextFvFile},
1653   {BBS_DEVICE_PATH, BBS_BBS_DP, DevPathToTextBBS},
1654   {END_DEVICE_PATH_TYPE, END_INSTANCE_DEVICE_PATH_SUBTYPE, DevPathToTextEndInstance},
1655   {0, 0, NULL}
1656 };
1657
1658 /**
1659   Converts a device node to its string representation.
1660
1661   @param DeviceNode        A Pointer to the device node to be converted.
1662   @param DisplayOnly       If DisplayOnly is TRUE, then the shorter text representation
1663                            of the display node is used, where applicable. If DisplayOnly
1664                            is FALSE, then the longer text representation of the display node
1665                            is used.
1666   @param AllowShortcuts    If AllowShortcuts is TRUE, then the shortcut forms of text
1667                            representation for a device node can be used, where applicable.
1668
1669   @return A pointer to the allocated text representation of the device node or NULL if DeviceNode
1670           is NULL or there was insufficient memory.
1671
1672 **/
1673 CHAR16 *
1674 EFIAPI
1675 ConvertDeviceNodeToText (
1676   IN CONST EFI_DEVICE_PATH_PROTOCOL  *DeviceNode,
1677   IN BOOLEAN                         DisplayOnly,
1678   IN BOOLEAN                         AllowShortcuts
1679   )
1680 {
1681   POOL_PRINT  Str;
1682   UINTN       Index;
1683   UINTN       NewSize;
1684   VOID        (*DumpNode)(POOL_PRINT *, VOID *, BOOLEAN, BOOLEAN);
1685
1686   if (DeviceNode == NULL) {
1687     return NULL;
1688   }
1689
1690   ZeroMem (&Str, sizeof (Str));
1691
1692   //
1693   // Process the device path node
1694   //
1695   DumpNode = NULL;
1696   for (Index = 0; DevPathToTextTable[Index].Function != NULL; Index++) {
1697     if (DevicePathType (DeviceNode) == DevPathToTextTable[Index].Type &&
1698         DevicePathSubType (DeviceNode) == DevPathToTextTable[Index].SubType
1699         ) {
1700       DumpNode = DevPathToTextTable[Index].Function;
1701       break;
1702     }
1703   }
1704   //
1705   // If not found, use a generic function
1706   //
1707   if (DumpNode == NULL) {
1708     DumpNode = DevPathToTextNodeUnknown;
1709   }
1710
1711   //
1712   // Print this node
1713   //
1714   DumpNode (&Str, (VOID *) DeviceNode, DisplayOnly, AllowShortcuts);
1715
1716   //
1717   // Shrink pool used for string allocation
1718   //
1719   NewSize = (Str.Len + 1) * sizeof (CHAR16);
1720   Str.Str = ReallocatePool (NewSize, NewSize, Str.Str);
1721   ASSERT (Str.Str != NULL);
1722   Str.Str[Str.Len] = 0;
1723   return Str.Str;
1724 }
1725
1726 /**
1727   Converts a device path to its text representation.
1728
1729   @param DevicePath      A Pointer to the device to be converted.
1730   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1731                          of the display node is used, where applicable. If DisplayOnly
1732                          is FALSE, then the longer text representation of the display node
1733                          is used.
1734   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1735                          representation for a device node can be used, where applicable.
1736
1737   @return A pointer to the allocated text representation of the device path or
1738           NULL if DeviceNode is NULL or there was insufficient memory.
1739
1740 **/
1741 CHAR16 *
1742 EFIAPI
1743 ConvertDevicePathToText (
1744   IN CONST EFI_DEVICE_PATH_PROTOCOL   *DevicePath,
1745   IN BOOLEAN                          DisplayOnly,
1746   IN BOOLEAN                          AllowShortcuts
1747   )
1748 {
1749   POOL_PRINT                Str;
1750   EFI_DEVICE_PATH_PROTOCOL  *DevPathNode;
1751   EFI_DEVICE_PATH_PROTOCOL  *AlignedDevPathNode;
1752   UINTN                     Index;
1753   UINTN                     NewSize;
1754   VOID                      (*DumpNode) (POOL_PRINT *, VOID *, BOOLEAN, BOOLEAN);
1755
1756   if (DevicePath == NULL) {
1757     return NULL;
1758   }
1759
1760   ZeroMem (&Str, sizeof (Str));
1761
1762   //
1763   // Process each device path node
1764   //
1765   DevPathNode = (EFI_DEVICE_PATH_PROTOCOL *) DevicePath;
1766   while (!IsDevicePathEnd (DevPathNode)) {
1767     //
1768     // Find the handler to dump this device path node
1769     //
1770     DumpNode = NULL;
1771     for (Index = 0; DevPathToTextTable[Index].Function; Index += 1) {
1772
1773       if (DevicePathType (DevPathNode) == DevPathToTextTable[Index].Type &&
1774           DevicePathSubType (DevPathNode) == DevPathToTextTable[Index].SubType
1775           ) {
1776         DumpNode = DevPathToTextTable[Index].Function;
1777         break;
1778       }
1779     }
1780     //
1781     // If not found, use a generic function
1782     //
1783     if (!DumpNode) {
1784       DumpNode = DevPathToTextNodeUnknown;
1785     }
1786     //
1787     //  Put a path seperator in if needed
1788     //
1789     if ((Str.Len != 0) && DumpNode != DevPathToTextEndInstance) {
1790       if (*(Str.Str + Str.Len / sizeof (CHAR16) - 1) != L',') {
1791         CatPrint (&Str, L"/");
1792       }
1793     }
1794
1795     AlignedDevPathNode = AllocateCopyPool (DevicePathNodeLength (DevPathNode), DevPathNode);
1796     //
1797     // Print this node of the device path
1798     //
1799     DumpNode (&Str, AlignedDevPathNode, DisplayOnly, AllowShortcuts);
1800     FreePool (AlignedDevPathNode);
1801
1802     //
1803     // Next device path node
1804     //
1805     DevPathNode = NextDevicePathNode (DevPathNode);
1806   }
1807
1808   NewSize = (Str.Len + 1) * sizeof (CHAR16);
1809   Str.Str = ReallocatePool (NewSize, NewSize, Str.Str);
1810   ASSERT (Str.Str != NULL);
1811   Str.Str[Str.Len] = 0;
1812   return Str.Str;
1813 }