MdePkg/Library/UefiDevicePathLib/DevicePathToText.c

   1 /** @file
   2   DevicePathToText protocol as defined in the UEFI 2.0 specification.
   3
   4   (C) Copyright 2015 Hewlett-Packard Development Company, L.P.<BR>
   5 Copyright (c) 2013 - 2017, Intel Corporation. All rights reserved.<BR>
   6 This program and the accompanying materials
   7 are licensed and made available under the terms and conditions of the BSD License
   8 which accompanies this distribution.  The full text of the license may be found at
   9 http://opensource.org/licenses/bsd-license.php
  10
  11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #include "UefiDevicePathLib.h"
  17
  18 /**
  19   Concatenates a formatted unicode string to allocated pool. The caller must
  20   free the resulting buffer.
  21
  22   @param Str             Tracks the allocated pool, size in use, and
  23                          amount of pool allocated.
  24   @param Fmt             The format string
  25   @param ...             Variable arguments based on the format string.
  26
  27   @return Allocated buffer with the formatted string printed in it.
  28           The caller must free the allocated buffer. The buffer
  29           allocation is not packed.
  30
  31 **/
  32 CHAR16 *
  33 EFIAPI
  34 UefiDevicePathLibCatPrint (
  35   IN OUT POOL_PRINT   *Str,
  36   IN CHAR16           *Fmt,
  37   ...
  38   )
  39 {
  40   UINTN   Count;
  41   VA_LIST Args;
  42
  43   VA_START (Args, Fmt);
  44   Count = SPrintLength (Fmt, Args);
  45   VA_END(Args);
  46
  47   if ((Str->Count + (Count + 1)) * sizeof (CHAR16) > Str->Capacity) {
  48     Str->Capacity = (Str->Count + (Count + 1) * 2) * sizeof (CHAR16);
  49     Str->Str = ReallocatePool (
  50                  Str->Count * sizeof (CHAR16),
  51                  Str->Capacity,
  52                  Str->Str
  53                  );
  54     ASSERT (Str->Str != NULL);
  55   }
  56   VA_START (Args, Fmt);
  57   UnicodeVSPrint (&Str->Str[Str->Count], Str->Capacity - Str->Count * sizeof (CHAR16), Fmt, Args);
  58   Str->Count += Count;
  59
  60   VA_END (Args);
  61   return Str->Str;
  62 }
  63
  64 /**
  65   Converts a PCI device path structure to its string representative.
  66
  67   @param Str             The string representative of input device.
  68   @param DevPath         The input device path structure.
  69   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
  70                          of the display node is used, where applicable. If DisplayOnly
  71                          is FALSE, then the longer text representation of the display node
  72                          is used.
  73   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
  74                          representation for a device node can be used, where applicable.
  75
  76 **/
  77 VOID
  78 DevPathToTextPci (
  79   IN OUT POOL_PRINT  *Str,
  80   IN VOID            *DevPath,
  81   IN BOOLEAN         DisplayOnly,
  82   IN BOOLEAN         AllowShortcuts
  83   )
  84 {
  85   PCI_DEVICE_PATH *Pci;
  86
  87   Pci = DevPath;
  88   UefiDevicePathLibCatPrint (Str, L"Pci(0x%x,0x%x)", Pci->Device, Pci->Function);
  89 }
  90
  91 /**
  92   Converts a PC Card device path structure to its string representative.
  93
  94   @param Str             The string representative of input device.
  95   @param DevPath         The input device path structure.
  96   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
  97                          of the display node is used, where applicable. If DisplayOnly
  98                          is FALSE, then the longer text representation of the display node
  99                          is used.
 100   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 101                          representation for a device node can be used, where applicable.
 102
 103 **/
 104 VOID
 105 DevPathToTextPccard (
 106   IN OUT POOL_PRINT  *Str,
 107   IN VOID            *DevPath,
 108   IN BOOLEAN         DisplayOnly,
 109   IN BOOLEAN         AllowShortcuts
 110   )
 111 {
 112   PCCARD_DEVICE_PATH  *Pccard;
 113
 114   Pccard = DevPath;
 115   UefiDevicePathLibCatPrint (Str, L"PcCard(0x%x)", Pccard->FunctionNumber);
 116 }
 117
 118 /**
 119   Converts a Memory Map device path structure to its string representative.
 120
 121   @param Str             The string representative of input device.
 122   @param DevPath         The input device path structure.
 123   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 124                          of the display node is used, where applicable. If DisplayOnly
 125                          is FALSE, then the longer text representation of the display node
 126                          is used.
 127   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 128                          representation for a device node can be used, where applicable.
 129
 130 **/
 131 VOID
 132 DevPathToTextMemMap (
 133   IN OUT POOL_PRINT  *Str,
 134   IN VOID            *DevPath,
 135   IN BOOLEAN         DisplayOnly,
 136   IN BOOLEAN         AllowShortcuts
 137   )
 138 {
 139   MEMMAP_DEVICE_PATH  *MemMap;
 140
 141   MemMap = DevPath;
 142   UefiDevicePathLibCatPrint (
 143     Str,
 144     L"MemoryMapped(0x%x,0x%lx,0x%lx)",
 145     MemMap->MemoryType,
 146     MemMap->StartingAddress,
 147     MemMap->EndingAddress
 148     );
 149 }
 150
 151 /**
 152   Converts a Vendor device path structure to its string representative.
 153
 154   @param Str             The string representative of input device.
 155   @param DevPath         The input device path structure.
 156   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 157                          of the display node is used, where applicable. If DisplayOnly
 158                          is FALSE, then the longer text representation of the display node
 159                          is used.
 160   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 161                          representation for a device node can be used, where applicable.
 162
 163 **/
 164 VOID
 165 DevPathToTextVendor (
 166   IN OUT POOL_PRINT  *Str,
 167   IN VOID            *DevPath,
 168   IN BOOLEAN         DisplayOnly,
 169   IN BOOLEAN         AllowShortcuts
 170   )
 171 {
 172   VENDOR_DEVICE_PATH  *Vendor;
 173   CHAR16              *Type;
 174   UINTN               Index;
 175   UINTN               DataLength;
 176   UINT32              FlowControlMap;
 177   UINT16              Info;
 178
 179   Vendor = (VENDOR_DEVICE_PATH *) DevPath;
 180   switch (DevicePathType (&Vendor->Header)) {
 181   case HARDWARE_DEVICE_PATH:
 182     Type = L"Hw";
 183     break;
 184
 185   case MESSAGING_DEVICE_PATH:
 186     Type = L"Msg";
 187     if (AllowShortcuts) {
 188       if (CompareGuid (&Vendor->Guid, &gEfiPcAnsiGuid)) {
 189         UefiDevicePathLibCatPrint (Str, L"VenPcAnsi()");
 190         return ;
 191       } else if (CompareGuid (&Vendor->Guid, &gEfiVT100Guid)) {
 192         UefiDevicePathLibCatPrint (Str, L"VenVt100()");
 193         return ;
 194       } else if (CompareGuid (&Vendor->Guid, &gEfiVT100PlusGuid)) {
 195         UefiDevicePathLibCatPrint (Str, L"VenVt100Plus()");
 196         return ;
 197       } else if (CompareGuid (&Vendor->Guid, &gEfiVTUTF8Guid)) {
 198         UefiDevicePathLibCatPrint (Str, L"VenUft8()");
 199         return ;
 200       } else if (CompareGuid (&Vendor->Guid, &gEfiUartDevicePathGuid)) {
 201         FlowControlMap = (((UART_FLOW_CONTROL_DEVICE_PATH *) Vendor)->FlowControlMap);
 202         switch (FlowControlMap & 0x00000003) {
 203         case 0:
 204           UefiDevicePathLibCatPrint (Str, L"UartFlowCtrl(%s)", L"None");
 205           break;
 206
 207         case 1:
 208           UefiDevicePathLibCatPrint (Str, L"UartFlowCtrl(%s)", L"Hardware");
 209           break;
 210
 211         case 2:
 212           UefiDevicePathLibCatPrint (Str, L"UartFlowCtrl(%s)", L"XonXoff");
 213           break;
 214
 215         default:
 216           break;
 217         }
 218
 219         return ;
 220       } else if (CompareGuid (&Vendor->Guid, &gEfiSasDevicePathGuid)) {
 221         UefiDevicePathLibCatPrint (
 222           Str,
 223           L"SAS(0x%lx,0x%lx,0x%x,",
 224           ((SAS_DEVICE_PATH *) Vendor)->SasAddress,
 225           ((SAS_DEVICE_PATH *) Vendor)->Lun,
 226           ((SAS_DEVICE_PATH *) Vendor)->RelativeTargetPort
 227           );
 228         Info = (((SAS_DEVICE_PATH *) Vendor)->DeviceTopology);
 229         if (((Info & 0x0f) == 0) && ((Info & BIT7) == 0)) {
 230           UefiDevicePathLibCatPrint (Str, L"NoTopology,0,0,0,");
 231         } else if (((Info & 0x0f) <= 2) && ((Info & BIT7) == 0)) {
 232           UefiDevicePathLibCatPrint (
 233             Str,
 234             L"%s,%s,%s,",
 235             ((Info & BIT4) != 0) ? L"SATA" : L"SAS",
 236             ((Info & BIT5) != 0) ? L"External" : L"Internal",
 237             ((Info & BIT6) != 0) ? L"Expanded" : L"Direct"
 238             );
 239           if ((Info & 0x0f) == 1) {
 240             UefiDevicePathLibCatPrint (Str, L"0,");
 241           } else {
 242             //
 243             // Value 0x0 thru 0xFF -> Drive 1 thru Drive 256
 244             //
 245             UefiDevicePathLibCatPrint (Str, L"0x%x,", ((Info >> 8) & 0xff) + 1);
 246           }
 247         } else {
 248           UefiDevicePathLibCatPrint (Str, L"0x%x,0,0,0,", Info);
 249         }
 250
 251         UefiDevicePathLibCatPrint (Str, L"0x%x)", ((SAS_DEVICE_PATH *) Vendor)->Reserved);
 252         return ;
 253       } else if (CompareGuid (&Vendor->Guid, &gEfiDebugPortProtocolGuid)) {
 254         UefiDevicePathLibCatPrint (Str, L"DebugPort()");
 255         return ;
 256       }
 257     }
 258     break;
 259
 260   case MEDIA_DEVICE_PATH:
 261     Type = L"Media";
 262     break;
 263
 264   default:
 265     Type = L"?";
 266     break;
 267   }
 268
 269   DataLength = DevicePathNodeLength (&Vendor->Header) - sizeof (VENDOR_DEVICE_PATH);
 270   UefiDevicePathLibCatPrint (Str, L"Ven%s(%g", Type, &Vendor->Guid);
 271   if (DataLength != 0) {
 272     UefiDevicePathLibCatPrint (Str, L",");
 273     for (Index = 0; Index < DataLength; Index++) {
 274       UefiDevicePathLibCatPrint (Str, L"%02x", ((VENDOR_DEVICE_PATH_WITH_DATA *) Vendor)->VendorDefinedData[Index]);
 275     }
 276   }
 277
 278   UefiDevicePathLibCatPrint (Str, L")");
 279 }
 280
 281 /**
 282   Converts a Controller device path structure to its string representative.
 283
 284   @param Str             The string representative of input device.
 285   @param DevPath         The input device path structure.
 286   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 287                          of the display node is used, where applicable. If DisplayOnly
 288                          is FALSE, then the longer text representation of the display node
 289                          is used.
 290   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 291                          representation for a device node can be used, where applicable.
 292
 293 **/
 294 VOID
 295 DevPathToTextController (
 296   IN OUT POOL_PRINT  *Str,
 297   IN VOID            *DevPath,
 298   IN BOOLEAN         DisplayOnly,
 299   IN BOOLEAN         AllowShortcuts
 300   )
 301 {
 302   CONTROLLER_DEVICE_PATH  *Controller;
 303
 304   Controller = DevPath;
 305   UefiDevicePathLibCatPrint (
 306     Str,
 307     L"Ctrl(0x%x)",
 308     Controller->ControllerNumber
 309     );
 310 }
 311
 312 /**
 313   Converts a BMC device path structure to its string representative.
 314
 315   @param Str             The string representative of input device.
 316   @param DevPath         The input device path structure.
 317   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 318                          of the display node is used, where applicable. If DisplayOnly
 319                          is FALSE, then the longer text representation of the display node
 320                          is used.
 321   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 322                          representation for a device node can be used, where applicable.
 323
 324 **/
 325 VOID
 326 DevPathToTextBmc (
 327   IN OUT POOL_PRINT  *Str,
 328   IN VOID            *DevPath,
 329   IN BOOLEAN         DisplayOnly,
 330   IN BOOLEAN         AllowShortcuts
 331   )
 332 {
 333   BMC_DEVICE_PATH    *Bmc;
 334
 335   Bmc = DevPath;
 336   UefiDevicePathLibCatPrint (
 337     Str,
 338     L"BMC(0x%x,0x%lx)",
 339     Bmc->InterfaceType,
 340     ReadUnaligned64 ((UINT64 *) (&Bmc->BaseAddress))
 341     );
 342 }
 343
 344 /**
 345   Converts a ACPI device path structure to its string representative.
 346
 347   @param Str             The string representative of input device.
 348   @param DevPath         The input device path structure.
 349   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 350                          of the display node is used, where applicable. If DisplayOnly
 351                          is FALSE, then the longer text representation of the display node
 352                          is used.
 353   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 354                          representation for a device node can be used, where applicable.
 355
 356 **/
 357 VOID
 358 DevPathToTextAcpi (
 359   IN OUT POOL_PRINT  *Str,
 360   IN VOID            *DevPath,
 361   IN BOOLEAN         DisplayOnly,
 362   IN BOOLEAN         AllowShortcuts
 363   )
 364 {
 365   ACPI_HID_DEVICE_PATH  *Acpi;
 366
 367   Acpi = DevPath;
 368   if ((Acpi->HID & PNP_EISA_ID_MASK) == PNP_EISA_ID_CONST) {
 369     switch (EISA_ID_TO_NUM (Acpi->HID)) {
 370     case 0x0a03:
 371       UefiDevicePathLibCatPrint (Str, L"PciRoot(0x%x)", Acpi->UID);
 372       break;
 373
 374     case 0x0a08:
 375       UefiDevicePathLibCatPrint (Str, L"PcieRoot(0x%x)", Acpi->UID);
 376       break;
 377
 378     case 0x0604:
 379       UefiDevicePathLibCatPrint (Str, L"Floppy(0x%x)", Acpi->UID);
 380       break;
 381
 382     case 0x0301:
 383       UefiDevicePathLibCatPrint (Str, L"Keyboard(0x%x)", Acpi->UID);
 384       break;
 385
 386     case 0x0501:
 387       UefiDevicePathLibCatPrint (Str, L"Serial(0x%x)", Acpi->UID);
 388       break;
 389
 390     case 0x0401:
 391       UefiDevicePathLibCatPrint (Str, L"ParallelPort(0x%x)", Acpi->UID);
 392       break;
 393
 394     default:
 395       UefiDevicePathLibCatPrint (Str, L"Acpi(PNP%04x,0x%x)", EISA_ID_TO_NUM (Acpi->HID), Acpi->UID);
 396       break;
 397     }
 398   } else {
 399     UefiDevicePathLibCatPrint (Str, L"Acpi(0x%08x,0x%x)", Acpi->HID, Acpi->UID);
 400   }
 401 }
 402
 403 /**
 404   Converts a ACPI extended HID device path structure to its string representative.
 405
 406   @param Str             The string representative of input device.
 407   @param DevPath         The input device path structure.
 408   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 409                          of the display node is used, where applicable. If DisplayOnly
 410                          is FALSE, then the longer text representation of the display node
 411                          is used.
 412   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 413                          representation for a device node can be used, where applicable.
 414
 415 **/
 416 VOID
 417 DevPathToTextAcpiEx (
 418   IN OUT POOL_PRINT  *Str,
 419   IN VOID            *DevPath,
 420   IN BOOLEAN         DisplayOnly,
 421   IN BOOLEAN         AllowShortcuts
 422   )
 423 {
 424   ACPI_EXTENDED_HID_DEVICE_PATH  *AcpiEx;
 425   CHAR8                          *HIDStr;
 426   CHAR8                          *UIDStr;
 427   CHAR8                          *CIDStr;
 428   CHAR16                         HIDText[11];
 429   CHAR16                         CIDText[11];
 430
 431   AcpiEx = DevPath;
 432   HIDStr = (CHAR8 *) (((UINT8 *) AcpiEx) + sizeof (ACPI_EXTENDED_HID_DEVICE_PATH));
 433   UIDStr = HIDStr + AsciiStrLen (HIDStr) + 1;
 434   CIDStr = UIDStr + AsciiStrLen (UIDStr) + 1;
 435
 436   //
 437   // Converts EISA identification to string.
 438   //
 439   UnicodeSPrint (
 440     HIDText,
 441     sizeof (HIDText),
 442     L"%c%c%c%04X",
 443     ((AcpiEx->HID >> 10) & 0x1f) + 'A' - 1,
 444     ((AcpiEx->HID >>  5) & 0x1f) + 'A' - 1,
 445     ((AcpiEx->HID >>  0) & 0x1f) + 'A' - 1,
 446     (AcpiEx->HID >> 16) & 0xFFFF
 447     );
 448   UnicodeSPrint (
 449     CIDText,
 450     sizeof (CIDText),
 451     L"%c%c%c%04X",
 452     ((AcpiEx->CID >> 10) & 0x1f) + 'A' - 1,
 453     ((AcpiEx->CID >>  5) & 0x1f) + 'A' - 1,
 454     ((AcpiEx->CID >>  0) & 0x1f) + 'A' - 1,
 455     (AcpiEx->CID >> 16) & 0xFFFF
 456     );
 457
 458   if ((*HIDStr == '\0') && (*CIDStr == '\0') && (AcpiEx->UID == 0)) {
 459     //
 460     // use AcpiExp()
 461     //
 462     UefiDevicePathLibCatPrint (
 463       Str,
 464       L"AcpiExp(%s,%s,%a)",
 465       HIDText,
 466       CIDText,
 467       UIDStr
 468       );
 469   } else {
 470     if (AllowShortcuts) {
 471       //
 472       // display only
 473       //
 474       if (AcpiEx->HID == 0) {
 475         UefiDevicePathLibCatPrint (Str, L"AcpiEx(%a,", HIDStr);
 476       } else {
 477         UefiDevicePathLibCatPrint (Str, L"AcpiEx(%s,", HIDText);
 478       }
 479
 480       if (AcpiEx->UID == 0) {
 481         UefiDevicePathLibCatPrint (Str, L"%a,", UIDStr);
 482       } else {
 483         UefiDevicePathLibCatPrint (Str, L"0x%x,", AcpiEx->UID);
 484       }
 485
 486       if (AcpiEx->CID == 0) {
 487         UefiDevicePathLibCatPrint (Str, L"%a)", CIDStr);
 488       } else {
 489         UefiDevicePathLibCatPrint (Str, L"%s)", CIDText);
 490       }
 491     } else {
 492       UefiDevicePathLibCatPrint (
 493         Str,
 494         L"AcpiEx(%s,%s,0x%x,%a,%a,%a)",
 495         HIDText,
 496         CIDText,
 497         AcpiEx->UID,
 498         HIDStr,
 499         CIDStr,
 500         UIDStr
 501         );
 502     }
 503   }
 504 }
 505
 506 /**
 507   Converts a ACPI address device path structure to its string representative.
 508
 509   @param Str             The string representative of input device.
 510   @param DevPath         The input device path structure.
 511   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 512                          of the display node is used, where applicable. If DisplayOnly
 513                          is FALSE, then the longer text representation of the display node
 514                          is used.
 515   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 516                          representation for a device node can be used, where applicable.
 517
 518 **/
 519 VOID
 520 DevPathToTextAcpiAdr (
 521   IN OUT POOL_PRINT  *Str,
 522   IN VOID            *DevPath,
 523   IN BOOLEAN         DisplayOnly,
 524   IN BOOLEAN         AllowShortcuts
 525   )
 526 {
 527   ACPI_ADR_DEVICE_PATH    *AcpiAdr;
 528   UINT16                  Index;
 529   UINT16                  Length;
 530   UINT16                  AdditionalAdrCount;
 531
 532   AcpiAdr            = DevPath;
 533   Length             = (UINT16) DevicePathNodeLength ((EFI_DEVICE_PATH_PROTOCOL *) AcpiAdr);
 534   AdditionalAdrCount = (UINT16) ((Length - 8) / 4);
 535
 536   UefiDevicePathLibCatPrint (Str, L"AcpiAdr(0x%x", AcpiAdr->ADR);
 537   for (Index = 0; Index < AdditionalAdrCount; Index++) {
 538     UefiDevicePathLibCatPrint (Str, L",0x%x", *(UINT32 *) ((UINT8 *) AcpiAdr + 8 + Index * 4));
 539   }
 540   UefiDevicePathLibCatPrint (Str, L")");
 541 }
 542
 543 /**
 544   Converts a ATAPI device path structure to its string representative.
 545
 546   @param Str             The string representative of input device.
 547   @param DevPath         The input device path structure.
 548   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 549                          of the display node is used, where applicable. If DisplayOnly
 550                          is FALSE, then the longer text representation of the display node
 551                          is used.
 552   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 553                          representation for a device node can be used, where applicable.
 554
 555 **/
 556 VOID
 557 DevPathToTextAtapi (
 558   IN OUT POOL_PRINT  *Str,
 559   IN VOID            *DevPath,
 560   IN BOOLEAN         DisplayOnly,
 561   IN BOOLEAN         AllowShortcuts
 562   )
 563 {
 564   ATAPI_DEVICE_PATH *Atapi;
 565
 566   Atapi = DevPath;
 567
 568   if (DisplayOnly) {
 569     UefiDevicePathLibCatPrint (Str, L"Ata(0x%x)", Atapi->Lun);
 570   } else {
 571     UefiDevicePathLibCatPrint (
 572       Str,
 573       L"Ata(%s,%s,0x%x)",
 574       (Atapi->PrimarySecondary == 1) ? L"Secondary" : L"Primary",
 575       (Atapi->SlaveMaster == 1) ? L"Slave" : L"Master",
 576       Atapi->Lun
 577       );
 578   }
 579 }
 580
 581 /**
 582   Converts a SCSI device path structure to its string representative.
 583
 584   @param Str             The string representative of input device.
 585   @param DevPath         The input device path structure.
 586   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 587                          of the display node is used, where applicable. If DisplayOnly
 588                          is FALSE, then the longer text representation of the display node
 589                          is used.
 590   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 591                          representation for a device node can be used, where applicable.
 592
 593 **/
 594 VOID
 595 DevPathToTextScsi (
 596   IN OUT POOL_PRINT  *Str,
 597   IN VOID            *DevPath,
 598   IN BOOLEAN         DisplayOnly,
 599   IN BOOLEAN         AllowShortcuts
 600   )
 601 {
 602   SCSI_DEVICE_PATH  *Scsi;
 603
 604   Scsi = DevPath;
 605   UefiDevicePathLibCatPrint (Str, L"Scsi(0x%x,0x%x)", Scsi->Pun, Scsi->Lun);
 606 }
 607
 608 /**
 609   Converts a Fibre device path structure to its string representative.
 610
 611   @param Str             The string representative of input device.
 612   @param DevPath         The input device path structure.
 613   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 614                          of the display node is used, where applicable. If DisplayOnly
 615                          is FALSE, then the longer text representation of the display node
 616                          is used.
 617   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 618                          representation for a device node can be used, where applicable.
 619
 620 **/
 621 VOID
 622 DevPathToTextFibre (
 623   IN OUT POOL_PRINT  *Str,
 624   IN VOID            *DevPath,
 625   IN BOOLEAN         DisplayOnly,
 626   IN BOOLEAN         AllowShortcuts
 627   )
 628 {
 629   FIBRECHANNEL_DEVICE_PATH  *Fibre;
 630
 631   Fibre = DevPath;
 632   UefiDevicePathLibCatPrint (Str, L"Fibre(0x%lx,0x%lx)", Fibre->WWN, Fibre->Lun);
 633 }
 634
 635 /**
 636   Converts a FibreEx device path structure to its string representative.
 637
 638   @param Str             The string representative of input device.
 639   @param DevPath         The input device path structure.
 640   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 641                          of the display node is used, where applicable. If DisplayOnly
 642                          is FALSE, then the longer text representation of the display node
 643                          is used.
 644   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 645                          representation for a device node can be used, where applicable.
 646
 647 **/
 648 VOID
 649 DevPathToTextFibreEx (
 650   IN OUT POOL_PRINT  *Str,
 651   IN VOID            *DevPath,
 652   IN BOOLEAN         DisplayOnly,
 653   IN BOOLEAN         AllowShortcuts
 654   )
 655 {
 656   FIBRECHANNELEX_DEVICE_PATH  *FibreEx;
 657   UINTN                       Index;
 658
 659   FibreEx = DevPath;
 660   UefiDevicePathLibCatPrint (Str, L"FibreEx(0x");
 661   for (Index = 0; Index < sizeof (FibreEx->WWN) / sizeof (FibreEx->WWN[0]); Index++) {
 662     UefiDevicePathLibCatPrint (Str, L"%02x", FibreEx->WWN[Index]);
 663   }
 664   UefiDevicePathLibCatPrint (Str, L",0x");
 665   for (Index = 0; Index < sizeof (FibreEx->Lun) / sizeof (FibreEx->Lun[0]); Index++) {
 666     UefiDevicePathLibCatPrint (Str, L"%02x", FibreEx->Lun[Index]);
 667   }
 668   UefiDevicePathLibCatPrint (Str, L")");
 669 }
 670
 671 /**
 672   Converts a Sas Ex device path structure to its string representative.
 673
 674   @param Str             The string representative of input device.
 675   @param DevPath         The input device path structure.
 676   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 677                          of the display node is used, where applicable. If DisplayOnly
 678                          is FALSE, then the longer text representation of the display node
 679                          is used.
 680   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 681                          representation for a device node can be used, where applicable.
 682
 683 **/
 684 VOID
 685 DevPathToTextSasEx (
 686   IN OUT POOL_PRINT  *Str,
 687   IN VOID            *DevPath,
 688   IN BOOLEAN         DisplayOnly,
 689   IN BOOLEAN         AllowShortcuts
 690   )
 691 {
 692   SASEX_DEVICE_PATH  *SasEx;
 693   UINTN              Index;
 694
 695   SasEx = DevPath;
 696   UefiDevicePathLibCatPrint (Str, L"SasEx(0x");
 697
 698   for (Index = 0; Index < sizeof (SasEx->SasAddress) / sizeof (SasEx->SasAddress[0]); Index++) {
 699     UefiDevicePathLibCatPrint (Str, L"%02x", SasEx->SasAddress[Index]);
 700   }
 701   UefiDevicePathLibCatPrint (Str, L",0x");
 702   for (Index = 0; Index < sizeof (SasEx->Lun) / sizeof (SasEx->Lun[0]); Index++) {
 703     UefiDevicePathLibCatPrint (Str, L"%02x", SasEx->Lun[Index]);
 704   }
 705   UefiDevicePathLibCatPrint (Str, L",0x%x,", SasEx->RelativeTargetPort);
 706
 707   if (((SasEx->DeviceTopology & 0x0f) == 0) && ((SasEx->DeviceTopology & BIT7) == 0)) {
 708     UefiDevicePathLibCatPrint (Str, L"NoTopology,0,0,0");
 709   } else if (((SasEx->DeviceTopology & 0x0f) <= 2) && ((SasEx->DeviceTopology & BIT7) == 0)) {
 710     UefiDevicePathLibCatPrint (
 711       Str,
 712       L"%s,%s,%s,",
 713       ((SasEx->DeviceTopology & BIT4) != 0) ? L"SATA" : L"SAS",
 714       ((SasEx->DeviceTopology & BIT5) != 0) ? L"External" : L"Internal",
 715       ((SasEx->DeviceTopology & BIT6) != 0) ? L"Expanded" : L"Direct"
 716       );
 717     if ((SasEx->DeviceTopology & 0x0f) == 1) {
 718       UefiDevicePathLibCatPrint (Str, L"0");
 719     } else {
 720       //
 721       // Value 0x0 thru 0xFF -> Drive 1 thru Drive 256
 722       //
 723       UefiDevicePathLibCatPrint (Str, L"0x%x", ((SasEx->DeviceTopology >> 8) & 0xff) + 1);
 724     }
 725   } else {
 726     UefiDevicePathLibCatPrint (Str, L"0x%x,0,0,0", SasEx->DeviceTopology);
 727   }
 728
 729   UefiDevicePathLibCatPrint (Str, L")");
 730   return ;
 731
 732 }
 733
 734 /**
 735   Converts a NVM Express Namespace device path structure to its string representative.
 736
 737   @param Str             The string representative of input device.
 738   @param DevPath         The input device path structure.
 739   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 740                          of the display node is used, where applicable. If DisplayOnly
 741                          is FALSE, then the longer text representation of the display node
 742                          is used.
 743   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 744                          representation for a device node can be used, where applicable.
 745
 746 **/
 747 VOID
 748 DevPathToTextNVMe (
 749   IN OUT POOL_PRINT  *Str,
 750   IN VOID            *DevPath,
 751   IN BOOLEAN         DisplayOnly,
 752   IN BOOLEAN         AllowShortcuts
 753   )
 754 {
 755   NVME_NAMESPACE_DEVICE_PATH *Nvme;
 756   UINT8                      *Uuid;
 757
 758   Nvme = DevPath;
 759   Uuid = (UINT8 *) &Nvme->NamespaceUuid;
 760   UefiDevicePathLibCatPrint (
 761     Str,
 762     L"NVMe(0x%x,%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x)",
 763     Nvme->NamespaceId,
 764     Uuid[7], Uuid[6], Uuid[5], Uuid[4],
 765     Uuid[3], Uuid[2], Uuid[1], Uuid[0]
 766     );
 767 }
 768
 769 /**
 770   Converts a UFS device path structure to its string representative.
 771
 772   @param Str             The string representative of input device.
 773   @param DevPath         The input device path structure.
 774   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 775                          of the display node is used, where applicable. If DisplayOnly
 776                          is FALSE, then the longer text representation of the display node
 777                          is used.
 778   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 779                          representation for a device node can be used, where applicable.
 780
 781 **/
 782 VOID
 783 DevPathToTextUfs (
 784   IN OUT POOL_PRINT  *Str,
 785   IN VOID            *DevPath,
 786   IN BOOLEAN         DisplayOnly,
 787   IN BOOLEAN         AllowShortcuts
 788   )
 789 {
 790   UFS_DEVICE_PATH  *Ufs;
 791
 792   Ufs = DevPath;
 793   UefiDevicePathLibCatPrint (Str, L"UFS(0x%x,0x%x)", Ufs->Pun, Ufs->Lun);
 794 }
 795
 796 /**
 797   Converts a SD (Secure Digital) device path structure to its string representative.
 798
 799   @param Str             The string representative of input device.
 800   @param DevPath         The input device path structure.
 801   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 802                          of the display node is used, where applicable. If DisplayOnly
 803                          is FALSE, then the longer text representation of the display node
 804                          is used.
 805   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 806                          representation for a device node can be used, where applicable.
 807
 808 **/
 809 VOID
 810 DevPathToTextSd (
 811   IN OUT POOL_PRINT  *Str,
 812   IN VOID            *DevPath,
 813   IN BOOLEAN         DisplayOnly,
 814   IN BOOLEAN         AllowShortcuts
 815   )
 816 {
 817   SD_DEVICE_PATH             *Sd;
 818
 819   Sd = DevPath;
 820   UefiDevicePathLibCatPrint (
 821     Str,
 822     L"SD(0x%x)",
 823     Sd->SlotNumber
 824     );
 825 }
 826
 827 /**
 828   Converts a EMMC (Embedded MMC) device path structure to its string representative.
 829
 830   @param Str             The string representative of input device.
 831   @param DevPath         The input device path structure.
 832   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 833                          of the display node is used, where applicable. If DisplayOnly
 834                          is FALSE, then the longer text representation of the display node
 835                          is used.
 836   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 837                          representation for a device node can be used, where applicable.
 838
 839 **/
 840 VOID
 841 DevPathToTextEmmc (
 842   IN OUT POOL_PRINT  *Str,
 843   IN VOID            *DevPath,
 844   IN BOOLEAN         DisplayOnly,
 845   IN BOOLEAN         AllowShortcuts
 846   )
 847 {
 848   EMMC_DEVICE_PATH             *Emmc;
 849
 850   Emmc = DevPath;
 851   UefiDevicePathLibCatPrint (
 852     Str,
 853     L"eMMC(0x%x)",
 854     Emmc->SlotNumber
 855     );
 856 }
 857
 858 /**
 859   Converts a 1394 device path structure to its string representative.
 860
 861   @param Str             The string representative of input device.
 862   @param DevPath         The input device path structure.
 863   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 864                          of the display node is used, where applicable. If DisplayOnly
 865                          is FALSE, then the longer text representation of the display node
 866                          is used.
 867   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 868                          representation for a device node can be used, where applicable.
 869
 870 **/
 871 VOID
 872 DevPathToText1394 (
 873   IN OUT POOL_PRINT  *Str,
 874   IN VOID            *DevPath,
 875   IN BOOLEAN         DisplayOnly,
 876   IN BOOLEAN         AllowShortcuts
 877   )
 878 {
 879   F1394_DEVICE_PATH *F1394DevPath;
 880
 881   F1394DevPath = DevPath;
 882   //
 883   // Guid has format of IEEE-EUI64
 884   //
 885   UefiDevicePathLibCatPrint (Str, L"I1394(%016lx)", F1394DevPath->Guid);
 886 }
 887
 888 /**
 889   Converts a USB 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 DevPathToTextUsb (
 903   IN OUT POOL_PRINT  *Str,
 904   IN VOID            *DevPath,
 905   IN BOOLEAN         DisplayOnly,
 906   IN BOOLEAN         AllowShortcuts
 907   )
 908 {
 909   USB_DEVICE_PATH *Usb;
 910
 911   Usb = DevPath;
 912   UefiDevicePathLibCatPrint (Str, L"USB(0x%x,0x%x)", Usb->ParentPortNumber, Usb->InterfaceNumber);
 913 }
 914
 915 /**
 916   Converts a USB WWID device path structure to its string representative.
 917
 918   @param Str             The string representative of input device.
 919   @param DevPath         The input device path structure.
 920   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 921                          of the display node is used, where applicable. If DisplayOnly
 922                          is FALSE, then the longer text representation of the display node
 923                          is used.
 924   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 925                          representation for a device node can be used, where applicable.
 926
 927 **/
 928 VOID
 929 DevPathToTextUsbWWID (
 930   IN OUT POOL_PRINT  *Str,
 931   IN VOID            *DevPath,
 932   IN BOOLEAN         DisplayOnly,
 933   IN BOOLEAN         AllowShortcuts
 934   )
 935 {
 936   USB_WWID_DEVICE_PATH  *UsbWWId;
 937   CHAR16                *SerialNumberStr;
 938   CHAR16                *NewStr;
 939   UINT16                Length;
 940
 941   UsbWWId = DevPath;
 942
 943   SerialNumberStr = (CHAR16 *) ((UINT8 *) UsbWWId + sizeof (USB_WWID_DEVICE_PATH));
 944   Length = (UINT16) ((DevicePathNodeLength ((EFI_DEVICE_PATH_PROTOCOL *) UsbWWId) - sizeof (USB_WWID_DEVICE_PATH)) / sizeof (CHAR16));
 945   if (SerialNumberStr [Length - 1] != 0) {
 946     //
 947     // In case no NULL terminator in SerialNumber, create a new one with NULL terminator
 948     //
 949     NewStr = AllocateCopyPool ((Length + 1) * sizeof (CHAR16), SerialNumberStr);
 950     ASSERT (NewStr != NULL);
 951     NewStr [Length] = 0;
 952     SerialNumberStr = NewStr;
 953   }
 954
 955   UefiDevicePathLibCatPrint (
 956     Str,
 957     L"UsbWwid(0x%x,0x%x,0x%x,\"%s\")",
 958     UsbWWId->VendorId,
 959     UsbWWId->ProductId,
 960     UsbWWId->InterfaceNumber,
 961     SerialNumberStr
 962     );
 963 }
 964
 965 /**
 966   Converts a Logic Unit device path structure to its string representative.
 967
 968   @param Str             The string representative of input device.
 969   @param DevPath         The input device path structure.
 970   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 971                          of the display node is used, where applicable. If DisplayOnly
 972                          is FALSE, then the longer text representation of the display node
 973                          is used.
 974   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 975                          representation for a device node can be used, where applicable.
 976
 977 **/
 978 VOID
 979 DevPathToTextLogicalUnit (
 980   IN OUT POOL_PRINT  *Str,
 981   IN VOID            *DevPath,
 982   IN BOOLEAN         DisplayOnly,
 983   IN BOOLEAN         AllowShortcuts
 984   )
 985 {
 986   DEVICE_LOGICAL_UNIT_DEVICE_PATH *LogicalUnit;
 987
 988   LogicalUnit = DevPath;
 989   UefiDevicePathLibCatPrint (Str, L"Unit(0x%x)", LogicalUnit->Lun);
 990 }
 991
 992 /**
 993   Converts a USB class device path structure to its string representative.
 994
 995   @param Str             The string representative of input device.
 996   @param DevPath         The input device path structure.
 997   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 998                          of the display node is used, where applicable. If DisplayOnly
 999                          is FALSE, then the longer text representation of the display node
1000                          is used.
1001   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1002                          representation for a device node can be used, where applicable.
1003
1004 **/
1005 VOID
1006 DevPathToTextUsbClass (
1007   IN OUT POOL_PRINT  *Str,
1008   IN VOID            *DevPath,
1009   IN BOOLEAN         DisplayOnly,
1010   IN BOOLEAN         AllowShortcuts
1011   )
1012 {
1013   USB_CLASS_DEVICE_PATH *UsbClass;
1014   BOOLEAN               IsKnownSubClass;
1015
1016
1017   UsbClass = DevPath;
1018
1019   IsKnownSubClass = TRUE;
1020   switch (UsbClass->DeviceClass) {
1021   case USB_CLASS_AUDIO:
1022     UefiDevicePathLibCatPrint (Str, L"UsbAudio");
1023     break;
1024
1025   case USB_CLASS_CDCCONTROL:
1026     UefiDevicePathLibCatPrint (Str, L"UsbCDCControl");
1027     break;
1028
1029   case USB_CLASS_HID:
1030     UefiDevicePathLibCatPrint (Str, L"UsbHID");
1031     break;
1032
1033   case USB_CLASS_IMAGE:
1034     UefiDevicePathLibCatPrint (Str, L"UsbImage");
1035     break;
1036
1037   case USB_CLASS_PRINTER:
1038     UefiDevicePathLibCatPrint (Str, L"UsbPrinter");
1039     break;
1040
1041   case USB_CLASS_MASS_STORAGE:
1042     UefiDevicePathLibCatPrint (Str, L"UsbMassStorage");
1043     break;
1044
1045   case USB_CLASS_HUB:
1046     UefiDevicePathLibCatPrint (Str, L"UsbHub");
1047     break;
1048
1049   case USB_CLASS_CDCDATA:
1050     UefiDevicePathLibCatPrint (Str, L"UsbCDCData");
1051     break;
1052
1053   case USB_CLASS_SMART_CARD:
1054     UefiDevicePathLibCatPrint (Str, L"UsbSmartCard");
1055     break;
1056
1057   case USB_CLASS_VIDEO:
1058     UefiDevicePathLibCatPrint (Str, L"UsbVideo");
1059     break;
1060
1061   case USB_CLASS_DIAGNOSTIC:
1062     UefiDevicePathLibCatPrint (Str, L"UsbDiagnostic");
1063     break;
1064
1065   case USB_CLASS_WIRELESS:
1066     UefiDevicePathLibCatPrint (Str, L"UsbWireless");
1067     break;
1068
1069   default:
1070     IsKnownSubClass = FALSE;
1071     break;
1072   }
1073
1074   if (IsKnownSubClass) {
1075     UefiDevicePathLibCatPrint (
1076       Str,
1077       L"(0x%x,0x%x,0x%x,0x%x)",
1078       UsbClass->VendorId,
1079       UsbClass->ProductId,
1080       UsbClass->DeviceSubClass,
1081       UsbClass->DeviceProtocol
1082       );
1083     return;
1084   }
1085
1086   if (UsbClass->DeviceClass == USB_CLASS_RESERVE) {
1087     if (UsbClass->DeviceSubClass == USB_SUBCLASS_FW_UPDATE) {
1088       UefiDevicePathLibCatPrint (
1089         Str,
1090         L"UsbDeviceFirmwareUpdate(0x%x,0x%x,0x%x)",
1091         UsbClass->VendorId,
1092         UsbClass->ProductId,
1093         UsbClass->DeviceProtocol
1094         );
1095       return;
1096     } else if (UsbClass->DeviceSubClass == USB_SUBCLASS_IRDA_BRIDGE) {
1097       UefiDevicePathLibCatPrint (
1098         Str,
1099         L"UsbIrdaBridge(0x%x,0x%x,0x%x)",
1100         UsbClass->VendorId,
1101         UsbClass->ProductId,
1102         UsbClass->DeviceProtocol
1103         );
1104       return;
1105     } else if (UsbClass->DeviceSubClass == USB_SUBCLASS_TEST) {
1106       UefiDevicePathLibCatPrint (
1107         Str,
1108         L"UsbTestAndMeasurement(0x%x,0x%x,0x%x)",
1109         UsbClass->VendorId,
1110         UsbClass->ProductId,
1111         UsbClass->DeviceProtocol
1112         );
1113       return;
1114     }
1115   }
1116
1117   UefiDevicePathLibCatPrint (
1118     Str,
1119     L"UsbClass(0x%x,0x%x,0x%x,0x%x,0x%x)",
1120     UsbClass->VendorId,
1121     UsbClass->ProductId,
1122     UsbClass->DeviceClass,
1123     UsbClass->DeviceSubClass,
1124     UsbClass->DeviceProtocol
1125     );
1126 }
1127
1128 /**
1129   Converts a SATA device path structure to its string representative.
1130
1131   @param Str             The string representative of input device.
1132   @param DevPath         The input device path structure.
1133   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1134                          of the display node is used, where applicable. If DisplayOnly
1135                          is FALSE, then the longer text representation of the display node
1136                          is used.
1137   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1138                          representation for a device node can be used, where applicable.
1139
1140 **/
1141 VOID
1142 DevPathToTextSata (
1143   IN OUT POOL_PRINT  *Str,
1144   IN VOID            *DevPath,
1145   IN BOOLEAN         DisplayOnly,
1146   IN BOOLEAN         AllowShortcuts
1147   )
1148 {
1149   SATA_DEVICE_PATH *Sata;
1150
1151   Sata = DevPath;
1152   UefiDevicePathLibCatPrint (
1153     Str,
1154     L"Sata(0x%x,0x%x,0x%x)",
1155     Sata->HBAPortNumber,
1156     Sata->PortMultiplierPortNumber,
1157     Sata->Lun
1158     );
1159 }
1160
1161 /**
1162   Converts a I20 device path structure to its string representative.
1163
1164   @param Str             The string representative of input device.
1165   @param DevPath         The input device path structure.
1166   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1167                          of the display node is used, where applicable. If DisplayOnly
1168                          is FALSE, then the longer text representation of the display node
1169                          is used.
1170   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1171                          representation for a device node can be used, where applicable.
1172
1173 **/
1174 VOID
1175 DevPathToTextI2O (
1176   IN OUT POOL_PRINT  *Str,
1177   IN VOID            *DevPath,
1178   IN BOOLEAN         DisplayOnly,
1179   IN BOOLEAN         AllowShortcuts
1180   )
1181 {
1182   I2O_DEVICE_PATH *I2ODevPath;
1183
1184   I2ODevPath = DevPath;
1185   UefiDevicePathLibCatPrint (Str, L"I2O(0x%x)", I2ODevPath->Tid);
1186 }
1187
1188 /**
1189   Converts a MAC address device path structure to its string representative.
1190
1191   @param Str             The string representative of input device.
1192   @param DevPath         The input device path structure.
1193   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1194                          of the display node is used, where applicable. If DisplayOnly
1195                          is FALSE, then the longer text representation of the display node
1196                          is used.
1197   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1198                          representation for a device node can be used, where applicable.
1199
1200 **/
1201 VOID
1202 DevPathToTextMacAddr (
1203   IN OUT POOL_PRINT  *Str,
1204   IN VOID            *DevPath,
1205   IN BOOLEAN         DisplayOnly,
1206   IN BOOLEAN         AllowShortcuts
1207   )
1208 {
1209   MAC_ADDR_DEVICE_PATH  *MacDevPath;
1210   UINTN                 HwAddressSize;
1211   UINTN                 Index;
1212
1213   MacDevPath = DevPath;
1214
1215   HwAddressSize = sizeof (EFI_MAC_ADDRESS);
1216   if (MacDevPath->IfType == 0x01 || MacDevPath->IfType == 0x00) {
1217     HwAddressSize = 6;
1218   }
1219
1220   UefiDevicePathLibCatPrint (Str, L"MAC(");
1221
1222   for (Index = 0; Index < HwAddressSize; Index++) {
1223     UefiDevicePathLibCatPrint (Str, L"%02x", MacDevPath->MacAddress.Addr[Index]);
1224   }
1225
1226   UefiDevicePathLibCatPrint (Str, L",0x%x)", MacDevPath->IfType);
1227 }
1228
1229 /**
1230   Converts network protocol string to its text representation.
1231
1232   @param Str             The string representative of input device.
1233   @param Protocol        The network protocol ID.
1234
1235 **/
1236 VOID
1237 CatNetworkProtocol (
1238   IN OUT POOL_PRINT  *Str,
1239   IN UINT16          Protocol
1240   )
1241 {
1242   if (Protocol == RFC_1700_TCP_PROTOCOL) {
1243     UefiDevicePathLibCatPrint (Str, L"TCP");
1244   } else if (Protocol == RFC_1700_UDP_PROTOCOL) {
1245     UefiDevicePathLibCatPrint (Str, L"UDP");
1246   } else {
1247     UefiDevicePathLibCatPrint (Str, L"0x%x", Protocol);
1248   }
1249 }
1250
1251 /**
1252   Converts IP v4 address to its text representation.
1253
1254   @param Str             The string representative of input device.
1255   @param Address         The IP v4 address.
1256 **/
1257 VOID
1258 CatIPv4Address (
1259   IN OUT POOL_PRINT   *Str,
1260   IN EFI_IPv4_ADDRESS *Address
1261   )
1262 {
1263   UefiDevicePathLibCatPrint (Str, L"%d.%d.%d.%d", Address->Addr[0], Address->Addr[1], Address->Addr[2], Address->Addr[3]);
1264 }
1265
1266 /**
1267   Converts IP v6 address to its text representation.
1268
1269   @param Str             The string representative of input device.
1270   @param Address         The IP v6 address.
1271 **/
1272 VOID
1273 CatIPv6Address (
1274   IN OUT POOL_PRINT   *Str,
1275   IN EFI_IPv6_ADDRESS *Address
1276   )
1277 {
1278   UefiDevicePathLibCatPrint (
1279     Str, L"%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x",
1280     Address->Addr[0],  Address->Addr[1],
1281     Address->Addr[2],  Address->Addr[3],
1282     Address->Addr[4],  Address->Addr[5],
1283     Address->Addr[6],  Address->Addr[7],
1284     Address->Addr[8],  Address->Addr[9],
1285     Address->Addr[10], Address->Addr[11],
1286     Address->Addr[12], Address->Addr[13],
1287     Address->Addr[14], Address->Addr[15]
1288   );
1289 }
1290
1291 /**
1292   Converts a IPv4 device path structure to its string representative.
1293
1294   @param Str             The string representative of input device.
1295   @param DevPath         The input device path structure.
1296   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1297                          of the display node is used, where applicable. If DisplayOnly
1298                          is FALSE, then the longer text representation of the display node
1299                          is used.
1300   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1301                          representation for a device node can be used, where applicable.
1302
1303 **/
1304 VOID
1305 DevPathToTextIPv4 (
1306   IN OUT POOL_PRINT  *Str,
1307   IN VOID            *DevPath,
1308   IN BOOLEAN         DisplayOnly,
1309   IN BOOLEAN         AllowShortcuts
1310   )
1311 {
1312   IPv4_DEVICE_PATH  *IPDevPath;
1313
1314   IPDevPath = DevPath;
1315   UefiDevicePathLibCatPrint (Str, L"IPv4(");
1316   CatIPv4Address (Str, &IPDevPath->RemoteIpAddress);
1317
1318   if (DisplayOnly) {
1319     UefiDevicePathLibCatPrint (Str, L")");
1320     return ;
1321   }
1322
1323   UefiDevicePathLibCatPrint (Str, L",");
1324   CatNetworkProtocol (Str, IPDevPath->Protocol);
1325
1326   UefiDevicePathLibCatPrint (Str, L",%s,", IPDevPath->StaticIpAddress ? L"Static" : L"DHCP");
1327   CatIPv4Address (Str, &IPDevPath->LocalIpAddress);
1328   if (DevicePathNodeLength (IPDevPath) == sizeof (IPv4_DEVICE_PATH)) {
1329     UefiDevicePathLibCatPrint (Str, L",");
1330     CatIPv4Address (Str, &IPDevPath->GatewayIpAddress);
1331     UefiDevicePathLibCatPrint (Str, L",");
1332     CatIPv4Address (Str, &IPDevPath->SubnetMask);
1333   }
1334   UefiDevicePathLibCatPrint (Str, L")");
1335 }
1336
1337 /**
1338   Converts a IPv6 device path structure to its string representative.
1339
1340   @param Str             The string representative of input device.
1341   @param DevPath         The input device path structure.
1342   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1343                          of the display node is used, where applicable. If DisplayOnly
1344                          is FALSE, then the longer text representation of the display node
1345                          is used.
1346   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1347                          representation for a device node can be used, where applicable.
1348
1349 **/
1350 VOID
1351 DevPathToTextIPv6 (
1352   IN OUT POOL_PRINT  *Str,
1353   IN VOID            *DevPath,
1354   IN BOOLEAN         DisplayOnly,
1355   IN BOOLEAN         AllowShortcuts
1356   )
1357 {
1358   IPv6_DEVICE_PATH  *IPDevPath;
1359
1360   IPDevPath = DevPath;
1361   UefiDevicePathLibCatPrint (Str, L"IPv6(");
1362   CatIPv6Address (Str, &IPDevPath->RemoteIpAddress);
1363   if (DisplayOnly) {
1364     UefiDevicePathLibCatPrint (Str, L")");
1365     return ;
1366   }
1367
1368   UefiDevicePathLibCatPrint (Str, L",");
1369   CatNetworkProtocol (Str, IPDevPath->Protocol);
1370
1371   switch (IPDevPath->IpAddressOrigin) {
1372     case 0:
1373       UefiDevicePathLibCatPrint (Str, L",Static,");
1374       break;
1375     case 1:
1376       UefiDevicePathLibCatPrint (Str, L",StatelessAutoConfigure,");
1377       break;
1378     default:
1379       UefiDevicePathLibCatPrint (Str, L",StatefulAutoConfigure,");
1380       break;
1381   }
1382
1383   CatIPv6Address (Str, &IPDevPath->LocalIpAddress);
1384
1385   if (DevicePathNodeLength (IPDevPath) == sizeof (IPv6_DEVICE_PATH)) {
1386     UefiDevicePathLibCatPrint (Str, L",0x%x,", IPDevPath->PrefixLength);
1387     CatIPv6Address (Str, &IPDevPath->GatewayIpAddress);
1388   }
1389   UefiDevicePathLibCatPrint (Str, L")");
1390 }
1391
1392 /**
1393   Converts an Infini Band device path structure to its string representative.
1394
1395   @param Str             The string representative of input device.
1396   @param DevPath         The input device path structure.
1397   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1398                          of the display node is used, where applicable. If DisplayOnly
1399                          is FALSE, then the longer text representation of the display node
1400                          is used.
1401   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1402                          representation for a device node can be used, where applicable.
1403
1404 **/
1405 VOID
1406 DevPathToTextInfiniBand (
1407   IN OUT POOL_PRINT  *Str,
1408   IN VOID            *DevPath,
1409   IN BOOLEAN         DisplayOnly,
1410   IN BOOLEAN         AllowShortcuts
1411   )
1412 {
1413   INFINIBAND_DEVICE_PATH  *InfiniBand;
1414
1415   InfiniBand = DevPath;
1416   UefiDevicePathLibCatPrint (
1417     Str,
1418     L"Infiniband(0x%x,%g,0x%lx,0x%lx,0x%lx)",
1419     InfiniBand->ResourceFlags,
1420     InfiniBand->PortGid,
1421     InfiniBand->ServiceId,
1422     InfiniBand->TargetPortId,
1423     InfiniBand->DeviceId
1424     );
1425 }
1426
1427 /**
1428   Converts a UART device path structure to its string representative.
1429
1430   @param Str             The string representative of input device.
1431   @param DevPath         The input device path structure.
1432   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1433                          of the display node is used, where applicable. If DisplayOnly
1434                          is FALSE, then the longer text representation of the display node
1435                          is used.
1436   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1437                          representation for a device node can be used, where applicable.
1438
1439 **/
1440 VOID
1441 DevPathToTextUart (
1442   IN OUT POOL_PRINT  *Str,
1443   IN VOID            *DevPath,
1444   IN BOOLEAN         DisplayOnly,
1445   IN BOOLEAN         AllowShortcuts
1446   )
1447 {
1448   UART_DEVICE_PATH  *Uart;
1449   CHAR8             Parity;
1450
1451   Uart = DevPath;
1452   switch (Uart->Parity) {
1453   case 0:
1454     Parity = 'D';
1455     break;
1456
1457   case 1:
1458     Parity = 'N';
1459     break;
1460
1461   case 2:
1462     Parity = 'E';
1463     break;
1464
1465   case 3:
1466     Parity = 'O';
1467     break;
1468
1469   case 4:
1470     Parity = 'M';
1471     break;
1472
1473   case 5:
1474     Parity = 'S';
1475     break;
1476
1477   default:
1478     Parity = 'x';
1479     break;
1480   }
1481
1482   if (Uart->BaudRate == 0) {
1483     UefiDevicePathLibCatPrint (Str, L"Uart(DEFAULT,");
1484   } else {
1485     UefiDevicePathLibCatPrint (Str, L"Uart(%ld,", Uart->BaudRate);
1486   }
1487
1488   if (Uart->DataBits == 0) {
1489     UefiDevicePathLibCatPrint (Str, L"DEFAULT,");
1490   } else {
1491     UefiDevicePathLibCatPrint (Str, L"%d,", Uart->DataBits);
1492   }
1493
1494   UefiDevicePathLibCatPrint (Str, L"%c,", Parity);
1495
1496   switch (Uart->StopBits) {
1497   case 0:
1498     UefiDevicePathLibCatPrint (Str, L"D)");
1499     break;
1500
1501   case 1:
1502     UefiDevicePathLibCatPrint (Str, L"1)");
1503     break;
1504
1505   case 2:
1506     UefiDevicePathLibCatPrint (Str, L"1.5)");
1507     break;
1508
1509   case 3:
1510     UefiDevicePathLibCatPrint (Str, L"2)");
1511     break;
1512
1513   default:
1514     UefiDevicePathLibCatPrint (Str, L"x)");
1515     break;
1516   }
1517 }
1518
1519 /**
1520   Converts an iSCSI device path structure to its string representative.
1521
1522   @param Str             The string representative of input device.
1523   @param DevPath         The input device path structure.
1524   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1525                          of the display node is used, where applicable. If DisplayOnly
1526                          is FALSE, then the longer text representation of the display node
1527                          is used.
1528   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1529                          representation for a device node can be used, where applicable.
1530
1531 **/
1532 VOID
1533 DevPathToTextiSCSI (
1534   IN OUT POOL_PRINT  *Str,
1535   IN VOID            *DevPath,
1536   IN BOOLEAN         DisplayOnly,
1537   IN BOOLEAN         AllowShortcuts
1538   )
1539 {
1540   ISCSI_DEVICE_PATH_WITH_NAME *ISCSIDevPath;
1541   UINT16                      Options;
1542
1543   ISCSIDevPath = DevPath;
1544   UefiDevicePathLibCatPrint (
1545     Str,
1546     L"iSCSI(%a,0x%x,0x%lx,",
1547     ISCSIDevPath->TargetName,
1548     ISCSIDevPath->TargetPortalGroupTag,
1549     ISCSIDevPath->Lun
1550     );
1551
1552   Options = ISCSIDevPath->LoginOption;
1553   UefiDevicePathLibCatPrint (Str, L"%s,", (((Options >> 1) & 0x0001) != 0) ? L"CRC32C" : L"None");
1554   UefiDevicePathLibCatPrint (Str, L"%s,", (((Options >> 3) & 0x0001) != 0) ? L"CRC32C" : L"None");
1555   if (((Options >> 11) & 0x0001) != 0) {
1556     UefiDevicePathLibCatPrint (Str, L"%s,", L"None");
1557   } else if (((Options >> 12) & 0x0001) != 0) {
1558     UefiDevicePathLibCatPrint (Str, L"%s,", L"CHAP_UNI");
1559   } else {
1560     UefiDevicePathLibCatPrint (Str, L"%s,", L"CHAP_BI");
1561
1562   }
1563
1564   UefiDevicePathLibCatPrint (Str, L"%s)", (ISCSIDevPath->NetworkProtocol == 0) ? L"TCP" : L"reserved");
1565 }
1566
1567 /**
1568   Converts a VLAN device path structure to its string representative.
1569
1570   @param Str             The string representative of input device.
1571   @param DevPath         The input device path structure.
1572   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1573                          of the display node is used, where applicable. If DisplayOnly
1574                          is FALSE, then the longer text representation of the display node
1575                          is used.
1576   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1577                          representation for a device node can be used, where applicable.
1578
1579 **/
1580 VOID
1581 DevPathToTextVlan (
1582   IN OUT POOL_PRINT  *Str,
1583   IN VOID            *DevPath,
1584   IN BOOLEAN         DisplayOnly,
1585   IN BOOLEAN         AllowShortcuts
1586   )
1587 {
1588   VLAN_DEVICE_PATH  *Vlan;
1589
1590   Vlan = DevPath;
1591   UefiDevicePathLibCatPrint (Str, L"Vlan(%d)", Vlan->VlanId);
1592 }
1593
1594 /**
1595   Converts a Bluetooth device path structure to its string representative.
1596
1597   @param Str             The string representative of input device.
1598   @param DevPath         The input device path structure.
1599   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1600                          of the display node is used, where applicable. If DisplayOnly
1601                          is FALSE, then the longer text representation of the display node
1602                          is used.
1603   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1604                          representation for a device node can be used, where applicable.
1605
1606 **/
1607 VOID
1608 DevPathToTextBluetooth (
1609   IN OUT POOL_PRINT  *Str,
1610   IN VOID            *DevPath,
1611   IN BOOLEAN         DisplayOnly,
1612   IN BOOLEAN         AllowShortcuts
1613   )
1614 {
1615   BLUETOOTH_DEVICE_PATH  *Bluetooth;
1616
1617   Bluetooth = DevPath;
1618   UefiDevicePathLibCatPrint (
1619     Str,
1620     L"Bluetooth(%02x%02x%02x%02x%02x%02x)",
1621     Bluetooth->BD_ADDR.Address[0],
1622     Bluetooth->BD_ADDR.Address[1],
1623     Bluetooth->BD_ADDR.Address[2],
1624     Bluetooth->BD_ADDR.Address[3],
1625     Bluetooth->BD_ADDR.Address[4],
1626     Bluetooth->BD_ADDR.Address[5]
1627     );
1628 }
1629
1630 /**
1631   Converts a Wi-Fi device path structure to its string representative.
1632
1633   @param Str             The string representative of input device.
1634   @param DevPath         The input device path structure.
1635   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1636                          of the display node is used, where applicable. If DisplayOnly
1637                          is FALSE, then the longer text representation of the display node
1638                          is used.
1639   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1640                          representation for a device node can be used, where applicable.
1641
1642 **/
1643 VOID
1644 DevPathToTextWiFi (
1645   IN OUT POOL_PRINT  *Str,
1646   IN VOID            *DevPath,
1647   IN BOOLEAN         DisplayOnly,
1648   IN BOOLEAN         AllowShortcuts
1649   )
1650 {
1651   WIFI_DEVICE_PATH      *WiFi;
1652   UINT8                 SSId[33];
1653
1654   WiFi = DevPath;
1655
1656   SSId[32] = '\0';
1657   CopyMem (SSId, WiFi->SSId, 32);
1658
1659   UefiDevicePathLibCatPrint (Str, L"Wi-Fi(%a)", SSId);
1660 }
1661
1662 /**
1663   Converts a Bluetooth device path structure to its string representative.
1664
1665   @param Str             The string representative of input device.
1666   @param DevPath         The input device path structure.
1667   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1668                          of the display node is used, where applicable. If DisplayOnly
1669                          is FALSE, then the longer text representation of the display node
1670                          is used.
1671   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1672                          representation for a device node can be used, where applicable.
1673
1674 **/
1675 VOID
1676 DevPathToTextBluetoothLE (
1677   IN OUT POOL_PRINT  *Str,
1678   IN VOID            *DevPath,
1679   IN BOOLEAN         DisplayOnly,
1680   IN BOOLEAN         AllowShortcuts
1681   )
1682 {
1683   BLUETOOTH_LE_DEVICE_PATH  *BluetoothLE;
1684
1685   BluetoothLE = DevPath;
1686   UefiDevicePathLibCatPrint (
1687     Str,
1688     L"BluetoothLE(%02x%02x%02x%02x%02x%02x,0x%02x)",
1689     BluetoothLE->Address.Address[0],
1690     BluetoothLE->Address.Address[1],
1691     BluetoothLE->Address.Address[2],
1692     BluetoothLE->Address.Address[3],
1693     BluetoothLE->Address.Address[4],
1694     BluetoothLE->Address.Address[5],
1695     BluetoothLE->Address.Type
1696     );
1697 }
1698
1699 /**
1700   Converts a URI device path structure to its string representative.
1701
1702   @param Str             The string representative of input device.
1703   @param DevPath         The input device path structure.
1704   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1705                          of the display node is used, where applicable. If DisplayOnly
1706                          is FALSE, then the longer text representation of the display node
1707                          is used.
1708   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1709                          representation for a device node can be used, where applicable.
1710
1711 **/
1712 VOID
1713 DevPathToTextUri (
1714   IN OUT POOL_PRINT  *Str,
1715   IN VOID            *DevPath,
1716   IN BOOLEAN         DisplayOnly,
1717   IN BOOLEAN         AllowShortcuts
1718   )
1719 {
1720   URI_DEVICE_PATH    *Uri;
1721   UINTN              UriLength;
1722   CHAR8              *UriStr;
1723
1724   //
1725   // Uri in the device path may not be null terminated.
1726   //
1727   Uri       = DevPath;
1728   UriLength = DevicePathNodeLength (Uri) - sizeof (URI_DEVICE_PATH);
1729   UriStr = AllocatePool (UriLength + 1);
1730   ASSERT (UriStr != NULL);
1731
1732   CopyMem (UriStr, Uri->Uri, UriLength);
1733   UriStr[UriLength] = '\0';
1734   UefiDevicePathLibCatPrint (Str, L"Uri(%a)", UriStr);
1735   FreePool (UriStr);
1736 }
1737
1738 /**
1739   Converts a Hard drive device path structure to its string representative.
1740
1741   @param Str             The string representative of input device.
1742   @param DevPath         The input device path structure.
1743   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1744                          of the display node is used, where applicable. If DisplayOnly
1745                          is FALSE, then the longer text representation of the display node
1746                          is used.
1747   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1748                          representation for a device node can be used, where applicable.
1749
1750 **/
1751 VOID
1752 DevPathToTextHardDrive (
1753   IN OUT POOL_PRINT  *Str,
1754   IN VOID            *DevPath,
1755   IN BOOLEAN         DisplayOnly,
1756   IN BOOLEAN         AllowShortcuts
1757   )
1758 {
1759   HARDDRIVE_DEVICE_PATH *Hd;
1760
1761   Hd = DevPath;
1762   switch (Hd->SignatureType) {
1763   case SIGNATURE_TYPE_MBR:
1764     UefiDevicePathLibCatPrint (
1765       Str,
1766       L"HD(%d,%s,0x%08x,",
1767       Hd->PartitionNumber,
1768       L"MBR",
1769       *((UINT32 *) (&(Hd->Signature[0])))
1770       );
1771     break;
1772
1773   case SIGNATURE_TYPE_GUID:
1774     UefiDevicePathLibCatPrint (
1775       Str,
1776       L"HD(%d,%s,%g,",
1777       Hd->PartitionNumber,
1778       L"GPT",
1779       (EFI_GUID *) &(Hd->Signature[0])
1780       );
1781     break;
1782
1783   default:
1784     UefiDevicePathLibCatPrint (
1785       Str,
1786       L"HD(%d,%d,0,",
1787       Hd->PartitionNumber,
1788       Hd->SignatureType
1789       );
1790     break;
1791   }
1792
1793   UefiDevicePathLibCatPrint (Str, L"0x%lx,0x%lx)", Hd->PartitionStart, Hd->PartitionSize);
1794 }
1795
1796 /**
1797   Converts a CDROM device path structure to its string representative.
1798
1799   @param Str             The string representative of input device.
1800   @param DevPath         The input device path structure.
1801   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1802                          of the display node is used, where applicable. If DisplayOnly
1803                          is FALSE, then the longer text representation of the display node
1804                          is used.
1805   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1806                          representation for a device node can be used, where applicable.
1807
1808 **/
1809 VOID
1810 DevPathToTextCDROM (
1811   IN OUT POOL_PRINT  *Str,
1812   IN VOID            *DevPath,
1813   IN BOOLEAN         DisplayOnly,
1814   IN BOOLEAN         AllowShortcuts
1815   )
1816 {
1817   CDROM_DEVICE_PATH *Cd;
1818
1819   Cd = DevPath;
1820   if (DisplayOnly) {
1821     UefiDevicePathLibCatPrint (Str, L"CDROM(0x%x)", Cd->BootEntry);
1822     return ;
1823   }
1824
1825   UefiDevicePathLibCatPrint (Str, L"CDROM(0x%x,0x%lx,0x%lx)", Cd->BootEntry, Cd->PartitionStart, Cd->PartitionSize);
1826 }
1827
1828 /**
1829   Converts a File device path structure to its string representative.
1830
1831   @param Str             The string representative of input device.
1832   @param DevPath         The input device path structure.
1833   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1834                          of the display node is used, where applicable. If DisplayOnly
1835                          is FALSE, then the longer text representation of the display node
1836                          is used.
1837   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1838                          representation for a device node can be used, where applicable.
1839
1840 **/
1841 VOID
1842 DevPathToTextFilePath (
1843   IN OUT POOL_PRINT  *Str,
1844   IN VOID            *DevPath,
1845   IN BOOLEAN         DisplayOnly,
1846   IN BOOLEAN         AllowShortcuts
1847   )
1848 {
1849   FILEPATH_DEVICE_PATH  *Fp;
1850
1851   Fp = DevPath;
1852   UefiDevicePathLibCatPrint (Str, L"%s", Fp->PathName);
1853 }
1854
1855 /**
1856   Converts a Media protocol device path structure to its string representative.
1857
1858   @param Str             The string representative of input device.
1859   @param DevPath         The input device path structure.
1860   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1861                          of the display node is used, where applicable. If DisplayOnly
1862                          is FALSE, then the longer text representation of the display node
1863                          is used.
1864   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1865                          representation for a device node can be used, where applicable.
1866
1867 **/
1868 VOID
1869 DevPathToTextMediaProtocol (
1870   IN OUT POOL_PRINT  *Str,
1871   IN VOID            *DevPath,
1872   IN BOOLEAN         DisplayOnly,
1873   IN BOOLEAN         AllowShortcuts
1874   )
1875 {
1876   MEDIA_PROTOCOL_DEVICE_PATH  *MediaProt;
1877
1878   MediaProt = DevPath;
1879   UefiDevicePathLibCatPrint (Str, L"Media(%g)", &MediaProt->Protocol);
1880 }
1881
1882 /**
1883   Converts a Firmware Volume device path structure to its string representative.
1884
1885   @param Str             The string representative of input device.
1886   @param DevPath         The input device path structure.
1887   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1888                          of the display node is used, where applicable. If DisplayOnly
1889                          is FALSE, then the longer text representation of the display node
1890                          is used.
1891   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1892                          representation for a device node can be used, where applicable.
1893
1894 **/
1895 VOID
1896 DevPathToTextFv (
1897   IN OUT POOL_PRINT  *Str,
1898   IN VOID            *DevPath,
1899   IN BOOLEAN         DisplayOnly,
1900   IN BOOLEAN         AllowShortcuts
1901   )
1902 {
1903   MEDIA_FW_VOL_DEVICE_PATH  *Fv;
1904
1905   Fv = DevPath;
1906   UefiDevicePathLibCatPrint (Str, L"Fv(%g)", &Fv->FvName);
1907 }
1908
1909 /**
1910   Converts a Firmware Volume File device path structure to its string representative.
1911
1912   @param Str             The string representative of input device.
1913   @param DevPath         The input device path structure.
1914   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1915                          of the display node is used, where applicable. If DisplayOnly
1916                          is FALSE, then the longer text representation of the display node
1917                          is used.
1918   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1919                          representation for a device node can be used, where applicable.
1920
1921 **/
1922 VOID
1923 DevPathToTextFvFile (
1924   IN OUT POOL_PRINT  *Str,
1925   IN VOID            *DevPath,
1926   IN BOOLEAN         DisplayOnly,
1927   IN BOOLEAN         AllowShortcuts
1928   )
1929 {
1930   MEDIA_FW_VOL_FILEPATH_DEVICE_PATH  *FvFile;
1931
1932   FvFile = DevPath;
1933   UefiDevicePathLibCatPrint (Str, L"FvFile(%g)", &FvFile->FvFileName);
1934 }
1935
1936 /**
1937   Converts a Relative Offset device path structure to its string representative.
1938
1939   @param Str             The string representative of input device.
1940   @param DevPath         The input device path structure.
1941   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1942                          of the display node is used, where applicable. If DisplayOnly
1943                          is FALSE, then the longer text representation of the display node
1944                          is used.
1945   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1946                          representation for a device node can be used, where applicable.
1947
1948 **/
1949 VOID
1950 DevPathRelativeOffsetRange (
1951   IN OUT POOL_PRINT       *Str,
1952   IN VOID                 *DevPath,
1953   IN BOOLEAN              DisplayOnly,
1954   IN BOOLEAN              AllowShortcuts
1955   )
1956 {
1957   MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH *Offset;
1958
1959   Offset = DevPath;
1960   UefiDevicePathLibCatPrint (
1961     Str,
1962     L"Offset(0x%lx,0x%lx)",
1963     Offset->StartingOffset,
1964     Offset->EndingOffset
1965     );
1966 }
1967
1968 /**
1969   Converts a Ram Disk device path structure to its string representative.
1970
1971   @param Str             The string representative of input device.
1972   @param DevPath         The input device path structure.
1973   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1974                          of the display node is used, where applicable. If DisplayOnly
1975                          is FALSE, then the longer text representation of the display node
1976                          is used.
1977   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1978                          representation for a device node can be used, where applicable.
1979
1980 **/
1981 VOID
1982 DevPathToTextRamDisk (
1983   IN OUT POOL_PRINT       *Str,
1984   IN VOID                 *DevPath,
1985   IN BOOLEAN              DisplayOnly,
1986   IN BOOLEAN              AllowShortcuts
1987   )
1988 {
1989   MEDIA_RAM_DISK_DEVICE_PATH *RamDisk;
1990
1991   RamDisk = DevPath;
1992
1993   if (CompareGuid (&RamDisk->TypeGuid, &gEfiVirtualDiskGuid)) {
1994     UefiDevicePathLibCatPrint (
1995       Str,
1996       L"VirtualDisk(0x%lx,0x%lx,%d)",
1997       LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0],
1998       LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0],
1999       RamDisk->Instance
2000       );
2001   } else if (CompareGuid (&RamDisk->TypeGuid, &gEfiVirtualCdGuid)) {
2002     UefiDevicePathLibCatPrint (
2003       Str,
2004       L"VirtualCD(0x%lx,0x%lx,%d)",
2005       LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0],
2006       LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0],
2007       RamDisk->Instance
2008       );
2009   } else if (CompareGuid (&RamDisk->TypeGuid, &gEfiPersistentVirtualDiskGuid)) {
2010     UefiDevicePathLibCatPrint (
2011       Str,
2012       L"PersistentVirtualDisk(0x%lx,0x%lx,%d)",
2013       LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0],
2014       LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0],
2015       RamDisk->Instance
2016       );
2017   } else if (CompareGuid (&RamDisk->TypeGuid, &gEfiPersistentVirtualCdGuid)) {
2018     UefiDevicePathLibCatPrint (
2019       Str,
2020       L"PersistentVirtualCD(0x%lx,0x%lx,%d)",
2021       LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0],
2022       LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0],
2023       RamDisk->Instance
2024       );
2025   } else {
2026     UefiDevicePathLibCatPrint (
2027       Str,
2028       L"RamDisk(0x%lx,0x%lx,%d,%g)",
2029       LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0],
2030       LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0],
2031       RamDisk->Instance,
2032       &RamDisk->TypeGuid
2033       );
2034   }
2035 }
2036
2037 /**
2038   Converts a BIOS Boot Specification device path structure to its string representative.
2039
2040   @param Str             The string representative of input device.
2041   @param DevPath         The input device path structure.
2042   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
2043                          of the display node is used, where applicable. If DisplayOnly
2044                          is FALSE, then the longer text representation of the display node
2045                          is used.
2046   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
2047                          representation for a device node can be used, where applicable.
2048
2049 **/
2050 VOID
2051 DevPathToTextBBS (
2052   IN OUT POOL_PRINT  *Str,
2053   IN VOID            *DevPath,
2054   IN BOOLEAN         DisplayOnly,
2055   IN BOOLEAN         AllowShortcuts
2056   )
2057 {
2058   BBS_BBS_DEVICE_PATH *Bbs;
2059   CHAR16              *Type;
2060
2061   Bbs = DevPath;
2062   switch (Bbs->DeviceType) {
2063   case BBS_TYPE_FLOPPY:
2064     Type = L"Floppy";
2065     break;
2066
2067   case BBS_TYPE_HARDDRIVE:
2068     Type = L"HD";
2069     break;
2070
2071   case BBS_TYPE_CDROM:
2072     Type = L"CDROM";
2073     break;
2074
2075   case BBS_TYPE_PCMCIA:
2076     Type = L"PCMCIA";
2077     break;
2078
2079   case BBS_TYPE_USB:
2080     Type = L"USB";
2081     break;
2082
2083   case BBS_TYPE_EMBEDDED_NETWORK:
2084     Type = L"Network";
2085     break;
2086
2087   default:
2088     Type = NULL;
2089     break;
2090   }
2091
2092   if (Type != NULL) {
2093     UefiDevicePathLibCatPrint (Str, L"BBS(%s,%a", Type, Bbs->String);
2094   } else {
2095     UefiDevicePathLibCatPrint (Str, L"BBS(0x%x,%a", Bbs->DeviceType, Bbs->String);
2096   }
2097
2098   if (DisplayOnly) {
2099     UefiDevicePathLibCatPrint (Str, L")");
2100     return ;
2101   }
2102
2103   UefiDevicePathLibCatPrint (Str, L",0x%x)", Bbs->StatusFlag);
2104 }
2105
2106 /**
2107   Converts an End-of-Device-Path structure to its string representative.
2108
2109   @param Str             The string representative of input device.
2110   @param DevPath         The input device path structure.
2111   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
2112                          of the display node is used, where applicable. If DisplayOnly
2113                          is FALSE, then the longer text representation of the display node
2114                          is used.
2115   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
2116                          representation for a device node can be used, where applicable.
2117
2118 **/
2119 VOID
2120 DevPathToTextEndInstance (
2121   IN OUT POOL_PRINT  *Str,
2122   IN VOID            *DevPath,
2123   IN BOOLEAN         DisplayOnly,
2124   IN BOOLEAN         AllowShortcuts
2125   )
2126 {
2127   UefiDevicePathLibCatPrint (Str, L",");
2128 }
2129
2130 GLOBAL_REMOVE_IF_UNREFERENCED const DEVICE_PATH_TO_TEXT_GENERIC_TABLE mUefiDevicePathLibToTextTableGeneric[] = {
2131   {HARDWARE_DEVICE_PATH,  L"HardwarePath"   },
2132   {ACPI_DEVICE_PATH,      L"AcpiPath"       },
2133   {MESSAGING_DEVICE_PATH, L"Msg"            },
2134   {MEDIA_DEVICE_PATH,     L"MediaPath"      },
2135   {BBS_DEVICE_PATH,       L"BbsPath"        },
2136   {0, NULL}
2137 };
2138
2139 /**
2140   Converts an unknown device path structure to its string representative.
2141
2142   @param Str             The string representative of input device.
2143   @param DevPath         The input device path structure.
2144   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
2145                          of the display node is used, where applicable. If DisplayOnly
2146                          is FALSE, then the longer text representation of the display node
2147                          is used.
2148   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
2149                          representation for a device node can be used, where applicable.
2150
2151 **/
2152 VOID
2153 DevPathToTextNodeGeneric (
2154   IN OUT POOL_PRINT  *Str,
2155   IN VOID            *DevPath,
2156   IN BOOLEAN         DisplayOnly,
2157   IN BOOLEAN         AllowShortcuts
2158   )
2159 {
2160   EFI_DEVICE_PATH_PROTOCOL *Node;
2161   UINTN                    Index;
2162
2163   Node = DevPath;
2164
2165   for (Index = 0; mUefiDevicePathLibToTextTableGeneric[Index].Text != NULL; Index++) {
2166     if (DevicePathType (Node) == mUefiDevicePathLibToTextTableGeneric[Index].Type) {
2167       break;
2168     }
2169   }
2170
2171   if (mUefiDevicePathLibToTextTableGeneric[Index].Text == NULL) {
2172     //
2173     // It's a node whose type cannot be recognized
2174     //
2175     UefiDevicePathLibCatPrint (Str, L"Path(%d,%d", DevicePathType (Node), DevicePathSubType (Node));
2176   } else {
2177     //
2178     // It's a node whose type can be recognized
2179     //
2180     UefiDevicePathLibCatPrint (Str, L"%s(%d", mUefiDevicePathLibToTextTableGeneric[Index].Text, DevicePathSubType (Node));
2181   }
2182
2183   Index = sizeof (EFI_DEVICE_PATH_PROTOCOL);
2184   if (Index < DevicePathNodeLength (Node)) {
2185     UefiDevicePathLibCatPrint (Str, L",");
2186     for (; Index < DevicePathNodeLength (Node); Index++) {
2187       UefiDevicePathLibCatPrint (Str, L"%02x", ((UINT8 *) Node)[Index]);
2188     }
2189   }
2190
2191   UefiDevicePathLibCatPrint (Str, L")");
2192 }
2193
2194 GLOBAL_REMOVE_IF_UNREFERENCED const DEVICE_PATH_TO_TEXT_TABLE mUefiDevicePathLibToTextTable[] = {
2195   {HARDWARE_DEVICE_PATH,  HW_PCI_DP,                        DevPathToTextPci            },
2196   {HARDWARE_DEVICE_PATH,  HW_PCCARD_DP,                     DevPathToTextPccard         },
2197   {HARDWARE_DEVICE_PATH,  HW_MEMMAP_DP,                     DevPathToTextMemMap         },
2198   {HARDWARE_DEVICE_PATH,  HW_VENDOR_DP,                     DevPathToTextVendor         },
2199   {HARDWARE_DEVICE_PATH,  HW_CONTROLLER_DP,                 DevPathToTextController     },
2200   {HARDWARE_DEVICE_PATH,  HW_BMC_DP,                        DevPathToTextBmc            },
2201   {ACPI_DEVICE_PATH,      ACPI_DP,                          DevPathToTextAcpi           },
2202   {ACPI_DEVICE_PATH,      ACPI_EXTENDED_DP,                 DevPathToTextAcpiEx         },
2203   {ACPI_DEVICE_PATH,      ACPI_ADR_DP,                      DevPathToTextAcpiAdr        },
2204   {MESSAGING_DEVICE_PATH, MSG_ATAPI_DP,                     DevPathToTextAtapi          },
2205   {MESSAGING_DEVICE_PATH, MSG_SCSI_DP,                      DevPathToTextScsi           },
2206   {MESSAGING_DEVICE_PATH, MSG_FIBRECHANNEL_DP,              DevPathToTextFibre          },
2207   {MESSAGING_DEVICE_PATH, MSG_FIBRECHANNELEX_DP,            DevPathToTextFibreEx        },
2208   {MESSAGING_DEVICE_PATH, MSG_SASEX_DP,                     DevPathToTextSasEx          },
2209   {MESSAGING_DEVICE_PATH, MSG_NVME_NAMESPACE_DP,            DevPathToTextNVMe           },
2210   {MESSAGING_DEVICE_PATH, MSG_UFS_DP,                       DevPathToTextUfs            },
2211   {MESSAGING_DEVICE_PATH, MSG_SD_DP,                        DevPathToTextSd             },
2212   {MESSAGING_DEVICE_PATH, MSG_EMMC_DP,                      DevPathToTextEmmc           },
2213   {MESSAGING_DEVICE_PATH, MSG_1394_DP,                      DevPathToText1394           },
2214   {MESSAGING_DEVICE_PATH, MSG_USB_DP,                       DevPathToTextUsb            },
2215   {MESSAGING_DEVICE_PATH, MSG_USB_WWID_DP,                  DevPathToTextUsbWWID        },
2216   {MESSAGING_DEVICE_PATH, MSG_DEVICE_LOGICAL_UNIT_DP,       DevPathToTextLogicalUnit    },
2217   {MESSAGING_DEVICE_PATH, MSG_USB_CLASS_DP,                 DevPathToTextUsbClass       },
2218   {MESSAGING_DEVICE_PATH, MSG_SATA_DP,                      DevPathToTextSata           },
2219   {MESSAGING_DEVICE_PATH, MSG_I2O_DP,                       DevPathToTextI2O            },
2220   {MESSAGING_DEVICE_PATH, MSG_MAC_ADDR_DP,                  DevPathToTextMacAddr        },
2221   {MESSAGING_DEVICE_PATH, MSG_IPv4_DP,                      DevPathToTextIPv4           },
2222   {MESSAGING_DEVICE_PATH, MSG_IPv6_DP,                      DevPathToTextIPv6           },
2223   {MESSAGING_DEVICE_PATH, MSG_INFINIBAND_DP,                DevPathToTextInfiniBand     },
2224   {MESSAGING_DEVICE_PATH, MSG_UART_DP,                      DevPathToTextUart           },
2225   {MESSAGING_DEVICE_PATH, MSG_VENDOR_DP,                    DevPathToTextVendor         },
2226   {MESSAGING_DEVICE_PATH, MSG_ISCSI_DP,                     DevPathToTextiSCSI          },
2227   {MESSAGING_DEVICE_PATH, MSG_VLAN_DP,                      DevPathToTextVlan           },
2228   {MESSAGING_DEVICE_PATH, MSG_URI_DP,                       DevPathToTextUri            },
2229   {MESSAGING_DEVICE_PATH, MSG_BLUETOOTH_DP,                 DevPathToTextBluetooth      },
2230   {MESSAGING_DEVICE_PATH, MSG_WIFI_DP,                      DevPathToTextWiFi           },
2231   {MESSAGING_DEVICE_PATH, MSG_BLUETOOTH_LE_DP,              DevPathToTextBluetoothLE    },
2232   {MEDIA_DEVICE_PATH,     MEDIA_HARDDRIVE_DP,               DevPathToTextHardDrive      },
2233   {MEDIA_DEVICE_PATH,     MEDIA_CDROM_DP,                   DevPathToTextCDROM          },
2234   {MEDIA_DEVICE_PATH,     MEDIA_VENDOR_DP,                  DevPathToTextVendor         },
2235   {MEDIA_DEVICE_PATH,     MEDIA_PROTOCOL_DP,                DevPathToTextMediaProtocol  },
2236   {MEDIA_DEVICE_PATH,     MEDIA_FILEPATH_DP,                DevPathToTextFilePath       },
2237   {MEDIA_DEVICE_PATH,     MEDIA_PIWG_FW_VOL_DP,             DevPathToTextFv             },
2238   {MEDIA_DEVICE_PATH,     MEDIA_PIWG_FW_FILE_DP,            DevPathToTextFvFile         },
2239   {MEDIA_DEVICE_PATH,     MEDIA_RELATIVE_OFFSET_RANGE_DP,   DevPathRelativeOffsetRange  },
2240   {MEDIA_DEVICE_PATH,     MEDIA_RAM_DISK_DP,                DevPathToTextRamDisk        },
2241   {BBS_DEVICE_PATH,       BBS_BBS_DP,                       DevPathToTextBBS            },
2242   {END_DEVICE_PATH_TYPE,  END_INSTANCE_DEVICE_PATH_SUBTYPE, DevPathToTextEndInstance    },
2243   {0, 0, NULL}
2244 };
2245
2246 /**
2247   Converts a device node to its string representation.
2248
2249   @param DeviceNode        A Pointer to the device node to be converted.
2250   @param DisplayOnly       If DisplayOnly is TRUE, then the shorter text representation
2251                            of the display node is used, where applicable. If DisplayOnly
2252                            is FALSE, then the longer text representation of the display node
2253                            is used.
2254   @param AllowShortcuts    If AllowShortcuts is TRUE, then the shortcut forms of text
2255                            representation for a device node can be used, where applicable.
2256
2257   @return A pointer to the allocated text representation of the device node or NULL if DeviceNode
2258           is NULL or there was insufficient memory.
2259
2260 **/
2261 CHAR16 *
2262 EFIAPI
2263 UefiDevicePathLibConvertDeviceNodeToText (
2264   IN CONST EFI_DEVICE_PATH_PROTOCOL  *DeviceNode,
2265   IN BOOLEAN                         DisplayOnly,
2266   IN BOOLEAN                         AllowShortcuts
2267   )
2268 {
2269   POOL_PRINT          Str;
2270   UINTN               Index;
2271   DEVICE_PATH_TO_TEXT ToText;
2272
2273   if (DeviceNode == NULL) {
2274     return NULL;
2275   }
2276
2277   ZeroMem (&Str, sizeof (Str));
2278
2279   //
2280   // Process the device path node
2281   // If not found, use a generic function
2282   //
2283   ToText = DevPathToTextNodeGeneric;
2284   for (Index = 0; mUefiDevicePathLibToTextTable[Index].Function != NULL; Index++) {
2285     if (DevicePathType (DeviceNode) == mUefiDevicePathLibToTextTable[Index].Type &&
2286         DevicePathSubType (DeviceNode) == mUefiDevicePathLibToTextTable[Index].SubType
2287         ) {
2288       ToText = mUefiDevicePathLibToTextTable[Index].Function;
2289       break;
2290     }
2291   }
2292
2293   //
2294   // Print this node
2295   //
2296   ToText (&Str, (VOID *) DeviceNode, DisplayOnly, AllowShortcuts);
2297
2298   ASSERT (Str.Str != NULL);
2299   return Str.Str;
2300 }
2301
2302 /**
2303   Converts a device path to its text representation.
2304
2305   @param DevicePath      A Pointer to the device to be converted.
2306   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
2307                          of the display node is used, where applicable. If DisplayOnly
2308                          is FALSE, then the longer text representation of the display node
2309                          is used.
2310   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
2311                          representation for a device node can be used, where applicable.
2312
2313   @return A pointer to the allocated text representation of the device path or
2314           NULL if DeviceNode is NULL or there was insufficient memory.
2315
2316 **/
2317 CHAR16 *
2318 EFIAPI
2319 UefiDevicePathLibConvertDevicePathToText (
2320   IN CONST EFI_DEVICE_PATH_PROTOCOL   *DevicePath,
2321   IN BOOLEAN                          DisplayOnly,
2322   IN BOOLEAN                          AllowShortcuts
2323   )
2324 {
2325   POOL_PRINT               Str;
2326   EFI_DEVICE_PATH_PROTOCOL *Node;
2327   EFI_DEVICE_PATH_PROTOCOL *AlignedNode;
2328   UINTN                    Index;
2329   DEVICE_PATH_TO_TEXT      ToText;
2330
2331   if (DevicePath == NULL) {
2332     return NULL;
2333   }
2334
2335   ZeroMem (&Str, sizeof (Str));
2336
2337   //
2338   // Process each device path node
2339   //
2340   Node = (EFI_DEVICE_PATH_PROTOCOL *) DevicePath;
2341   while (!IsDevicePathEnd (Node)) {
2342     //
2343     // Find the handler to dump this device path node
2344     // If not found, use a generic function
2345     //
2346     ToText = DevPathToTextNodeGeneric;
2347     for (Index = 0; mUefiDevicePathLibToTextTable[Index].Function != NULL; Index += 1) {
2348
2349       if (DevicePathType (Node) == mUefiDevicePathLibToTextTable[Index].Type &&
2350           DevicePathSubType (Node) == mUefiDevicePathLibToTextTable[Index].SubType
2351           ) {
2352         ToText = mUefiDevicePathLibToTextTable[Index].Function;
2353         break;
2354       }
2355     }
2356     //
2357     //  Put a path separator in if needed
2358     //
2359     if ((Str.Count != 0) && (ToText != DevPathToTextEndInstance)) {
2360       if (Str.Str[Str.Count] != L',') {
2361         UefiDevicePathLibCatPrint (&Str, L"/");
2362       }
2363     }
2364
2365     AlignedNode = AllocateCopyPool (DevicePathNodeLength (Node), Node);
2366     //
2367     // Print this node of the device path
2368     //
2369     ToText (&Str, AlignedNode, DisplayOnly, AllowShortcuts);
2370     FreePool (AlignedNode);
2371
2372     //
2373     // Next device path node
2374     //
2375     Node = NextDevicePathNode (Node);
2376   }
2377
2378   if (Str.Str == NULL) {
2379     return AllocateZeroPool (sizeof (CHAR16));
2380   } else {
2381     return Str.Str;
2382   }
2383 }