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 - 2015, 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[5],
1622     Bluetooth->BD_ADDR.Address[4],
1623     Bluetooth->BD_ADDR.Address[3],
1624     Bluetooth->BD_ADDR.Address[2],
1625     Bluetooth->BD_ADDR.Address[1],
1626     Bluetooth->BD_ADDR.Address[0]
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 URI 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 DevPathToTextUri (
1677   IN OUT POOL_PRINT  *Str,
1678   IN VOID            *DevPath,
1679   IN BOOLEAN         DisplayOnly,
1680   IN BOOLEAN         AllowShortcuts
1681   )
1682 {
1683   URI_DEVICE_PATH    *Uri;
1684   UINTN              UriLength;
1685   CHAR8              *UriStr;
1686
1687   //
1688   // Uri in the device path may not be null terminated.
1689   //
1690   Uri       = DevPath;
1691   UriLength = DevicePathNodeLength (Uri) - sizeof (URI_DEVICE_PATH);
1692   UriStr = AllocatePool (UriLength + 1);
1693   ASSERT (UriStr != NULL);
1694
1695   CopyMem (UriStr, Uri->Uri, UriLength);
1696   UriStr[UriLength] = '\0';
1697   UefiDevicePathLibCatPrint (Str, L"Uri(%a)", UriStr);
1698   FreePool (UriStr);
1699 }
1700
1701 /**
1702   Converts a Hard drive device path structure to its string representative.
1703
1704   @param Str             The string representative of input device.
1705   @param DevPath         The input device path structure.
1706   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1707                          of the display node is used, where applicable. If DisplayOnly
1708                          is FALSE, then the longer text representation of the display node
1709                          is used.
1710   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1711                          representation for a device node can be used, where applicable.
1712
1713 **/
1714 VOID
1715 DevPathToTextHardDrive (
1716   IN OUT POOL_PRINT  *Str,
1717   IN VOID            *DevPath,
1718   IN BOOLEAN         DisplayOnly,
1719   IN BOOLEAN         AllowShortcuts
1720   )
1721 {
1722   HARDDRIVE_DEVICE_PATH *Hd;
1723
1724   Hd = DevPath;
1725   switch (Hd->SignatureType) {
1726   case SIGNATURE_TYPE_MBR:
1727     UefiDevicePathLibCatPrint (
1728       Str,
1729       L"HD(%d,%s,0x%08x,",
1730       Hd->PartitionNumber,
1731       L"MBR",
1732       *((UINT32 *) (&(Hd->Signature[0])))
1733       );
1734     break;
1735
1736   case SIGNATURE_TYPE_GUID:
1737     UefiDevicePathLibCatPrint (
1738       Str,
1739       L"HD(%d,%s,%g,",
1740       Hd->PartitionNumber,
1741       L"GPT",
1742       (EFI_GUID *) &(Hd->Signature[0])
1743       );
1744     break;
1745
1746   default:
1747     UefiDevicePathLibCatPrint (
1748       Str,
1749       L"HD(%d,%d,0,",
1750       Hd->PartitionNumber,
1751       Hd->SignatureType
1752       );
1753     break;
1754   }
1755
1756   UefiDevicePathLibCatPrint (Str, L"0x%lx,0x%lx)", Hd->PartitionStart, Hd->PartitionSize);
1757 }
1758
1759 /**
1760   Converts a CDROM device path structure to its string representative.
1761
1762   @param Str             The string representative of input device.
1763   @param DevPath         The input device path structure.
1764   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1765                          of the display node is used, where applicable. If DisplayOnly
1766                          is FALSE, then the longer text representation of the display node
1767                          is used.
1768   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1769                          representation for a device node can be used, where applicable.
1770
1771 **/
1772 VOID
1773 DevPathToTextCDROM (
1774   IN OUT POOL_PRINT  *Str,
1775   IN VOID            *DevPath,
1776   IN BOOLEAN         DisplayOnly,
1777   IN BOOLEAN         AllowShortcuts
1778   )
1779 {
1780   CDROM_DEVICE_PATH *Cd;
1781
1782   Cd = DevPath;
1783   if (DisplayOnly) {
1784     UefiDevicePathLibCatPrint (Str, L"CDROM(0x%x)", Cd->BootEntry);
1785     return ;
1786   }
1787
1788   UefiDevicePathLibCatPrint (Str, L"CDROM(0x%x,0x%lx,0x%lx)", Cd->BootEntry, Cd->PartitionStart, Cd->PartitionSize);
1789 }
1790
1791 /**
1792   Converts a File device path structure to its string representative.
1793
1794   @param Str             The string representative of input device.
1795   @param DevPath         The input device path structure.
1796   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1797                          of the display node is used, where applicable. If DisplayOnly
1798                          is FALSE, then the longer text representation of the display node
1799                          is used.
1800   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1801                          representation for a device node can be used, where applicable.
1802
1803 **/
1804 VOID
1805 DevPathToTextFilePath (
1806   IN OUT POOL_PRINT  *Str,
1807   IN VOID            *DevPath,
1808   IN BOOLEAN         DisplayOnly,
1809   IN BOOLEAN         AllowShortcuts
1810   )
1811 {
1812   FILEPATH_DEVICE_PATH  *Fp;
1813
1814   Fp = DevPath;
1815   UefiDevicePathLibCatPrint (Str, L"%s", Fp->PathName);
1816 }
1817
1818 /**
1819   Converts a Media protocol device path structure to its string representative.
1820
1821   @param Str             The string representative of input device.
1822   @param DevPath         The input device path structure.
1823   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1824                          of the display node is used, where applicable. If DisplayOnly
1825                          is FALSE, then the longer text representation of the display node
1826                          is used.
1827   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1828                          representation for a device node can be used, where applicable.
1829
1830 **/
1831 VOID
1832 DevPathToTextMediaProtocol (
1833   IN OUT POOL_PRINT  *Str,
1834   IN VOID            *DevPath,
1835   IN BOOLEAN         DisplayOnly,
1836   IN BOOLEAN         AllowShortcuts
1837   )
1838 {
1839   MEDIA_PROTOCOL_DEVICE_PATH  *MediaProt;
1840
1841   MediaProt = DevPath;
1842   UefiDevicePathLibCatPrint (Str, L"Media(%g)", &MediaProt->Protocol);
1843 }
1844
1845 /**
1846   Converts a Firmware Volume device path structure to its string representative.
1847
1848   @param Str             The string representative of input device.
1849   @param DevPath         The input device path structure.
1850   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1851                          of the display node is used, where applicable. If DisplayOnly
1852                          is FALSE, then the longer text representation of the display node
1853                          is used.
1854   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1855                          representation for a device node can be used, where applicable.
1856
1857 **/
1858 VOID
1859 DevPathToTextFv (
1860   IN OUT POOL_PRINT  *Str,
1861   IN VOID            *DevPath,
1862   IN BOOLEAN         DisplayOnly,
1863   IN BOOLEAN         AllowShortcuts
1864   )
1865 {
1866   MEDIA_FW_VOL_DEVICE_PATH  *Fv;
1867
1868   Fv = DevPath;
1869   UefiDevicePathLibCatPrint (Str, L"Fv(%g)", &Fv->FvName);
1870 }
1871
1872 /**
1873   Converts a Firmware Volume File device path structure to its string representative.
1874
1875   @param Str             The string representative of input device.
1876   @param DevPath         The input device path structure.
1877   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1878                          of the display node is used, where applicable. If DisplayOnly
1879                          is FALSE, then the longer text representation of the display node
1880                          is used.
1881   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1882                          representation for a device node can be used, where applicable.
1883
1884 **/
1885 VOID
1886 DevPathToTextFvFile (
1887   IN OUT POOL_PRINT  *Str,
1888   IN VOID            *DevPath,
1889   IN BOOLEAN         DisplayOnly,
1890   IN BOOLEAN         AllowShortcuts
1891   )
1892 {
1893   MEDIA_FW_VOL_FILEPATH_DEVICE_PATH  *FvFile;
1894
1895   FvFile = DevPath;
1896   UefiDevicePathLibCatPrint (Str, L"FvFile(%g)", &FvFile->FvFileName);
1897 }
1898
1899 /**
1900   Converts a Relative Offset device path structure to its string representative.
1901
1902   @param Str             The string representative of input device.
1903   @param DevPath         The input device path structure.
1904   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1905                          of the display node is used, where applicable. If DisplayOnly
1906                          is FALSE, then the longer text representation of the display node
1907                          is used.
1908   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1909                          representation for a device node can be used, where applicable.
1910
1911 **/
1912 VOID
1913 DevPathRelativeOffsetRange (
1914   IN OUT POOL_PRINT       *Str,
1915   IN VOID                 *DevPath,
1916   IN BOOLEAN              DisplayOnly,
1917   IN BOOLEAN              AllowShortcuts
1918   )
1919 {
1920   MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH *Offset;
1921
1922   Offset = DevPath;
1923   UefiDevicePathLibCatPrint (
1924     Str,
1925     L"Offset(0x%lx,0x%lx)",
1926     Offset->StartingOffset,
1927     Offset->EndingOffset
1928     );
1929 }
1930
1931 /**
1932   Converts a Ram Disk device path structure to its string representative.
1933
1934   @param Str             The string representative of input device.
1935   @param DevPath         The input device path structure.
1936   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1937                          of the display node is used, where applicable. If DisplayOnly
1938                          is FALSE, then the longer text representation of the display node
1939                          is used.
1940   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1941                          representation for a device node can be used, where applicable.
1942
1943 **/
1944 VOID
1945 DevPathToTextRamDisk (
1946   IN OUT POOL_PRINT       *Str,
1947   IN VOID                 *DevPath,
1948   IN BOOLEAN              DisplayOnly,
1949   IN BOOLEAN              AllowShortcuts
1950   )
1951 {
1952   MEDIA_RAM_DISK_DEVICE_PATH *RamDisk;
1953
1954   RamDisk = DevPath;
1955
1956   if (CompareGuid (&RamDisk->TypeGuid, &gEfiVirtualDiskGuid)) {
1957     UefiDevicePathLibCatPrint (
1958       Str,
1959       L"VirtualDisk(0x%lx,0x%lx,%d)",
1960       LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0],
1961       LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0],
1962       RamDisk->Instance
1963       );
1964   } else if (CompareGuid (&RamDisk->TypeGuid, &gEfiVirtualCdGuid)) {
1965     UefiDevicePathLibCatPrint (
1966       Str,
1967       L"VirtualCD(0x%lx,0x%lx,%d)",
1968       LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0],
1969       LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0],
1970       RamDisk->Instance
1971       );
1972   } else if (CompareGuid (&RamDisk->TypeGuid, &gEfiPersistentVirtualDiskGuid)) {
1973     UefiDevicePathLibCatPrint (
1974       Str,
1975       L"PersistentVirtualDisk(0x%lx,0x%lx,%d)",
1976       LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0],
1977       LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0],
1978       RamDisk->Instance
1979       );
1980   } else if (CompareGuid (&RamDisk->TypeGuid, &gEfiPersistentVirtualCdGuid)) {
1981     UefiDevicePathLibCatPrint (
1982       Str,
1983       L"PersistentVirtualCD(0x%lx,0x%lx,%d)",
1984       LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0],
1985       LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0],
1986       RamDisk->Instance
1987       );
1988   } else {
1989     UefiDevicePathLibCatPrint (
1990       Str,
1991       L"RamDisk(0x%lx,0x%lx,%d,%g)",
1992       LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0],
1993       LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0],
1994       RamDisk->Instance,
1995       &RamDisk->TypeGuid
1996       );
1997   }
1998 }
1999
2000 /**
2001   Converts a BIOS Boot Specification device path structure to its string representative.
2002
2003   @param Str             The string representative of input device.
2004   @param DevPath         The input device path structure.
2005   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
2006                          of the display node is used, where applicable. If DisplayOnly
2007                          is FALSE, then the longer text representation of the display node
2008                          is used.
2009   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
2010                          representation for a device node can be used, where applicable.
2011
2012 **/
2013 VOID
2014 DevPathToTextBBS (
2015   IN OUT POOL_PRINT  *Str,
2016   IN VOID            *DevPath,
2017   IN BOOLEAN         DisplayOnly,
2018   IN BOOLEAN         AllowShortcuts
2019   )
2020 {
2021   BBS_BBS_DEVICE_PATH *Bbs;
2022   CHAR16              *Type;
2023
2024   Bbs = DevPath;
2025   switch (Bbs->DeviceType) {
2026   case BBS_TYPE_FLOPPY:
2027     Type = L"Floppy";
2028     break;
2029
2030   case BBS_TYPE_HARDDRIVE:
2031     Type = L"HD";
2032     break;
2033
2034   case BBS_TYPE_CDROM:
2035     Type = L"CDROM";
2036     break;
2037
2038   case BBS_TYPE_PCMCIA:
2039     Type = L"PCMCIA";
2040     break;
2041
2042   case BBS_TYPE_USB:
2043     Type = L"USB";
2044     break;
2045
2046   case BBS_TYPE_EMBEDDED_NETWORK:
2047     Type = L"Network";
2048     break;
2049
2050   default:
2051     Type = NULL;
2052     break;
2053   }
2054
2055   if (Type != NULL) {
2056     UefiDevicePathLibCatPrint (Str, L"BBS(%s,%a", Type, Bbs->String);
2057   } else {
2058     UefiDevicePathLibCatPrint (Str, L"BBS(0x%x,%a", Bbs->DeviceType, Bbs->String);
2059   }
2060
2061   if (DisplayOnly) {
2062     UefiDevicePathLibCatPrint (Str, L")");
2063     return ;
2064   }
2065
2066   UefiDevicePathLibCatPrint (Str, L",0x%x)", Bbs->StatusFlag);
2067 }
2068
2069 /**
2070   Converts an End-of-Device-Path structure to its string representative.
2071
2072   @param Str             The string representative of input device.
2073   @param DevPath         The input device path structure.
2074   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
2075                          of the display node is used, where applicable. If DisplayOnly
2076                          is FALSE, then the longer text representation of the display node
2077                          is used.
2078   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
2079                          representation for a device node can be used, where applicable.
2080
2081 **/
2082 VOID
2083 DevPathToTextEndInstance (
2084   IN OUT POOL_PRINT  *Str,
2085   IN VOID            *DevPath,
2086   IN BOOLEAN         DisplayOnly,
2087   IN BOOLEAN         AllowShortcuts
2088   )
2089 {
2090   UefiDevicePathLibCatPrint (Str, L",");
2091 }
2092
2093 GLOBAL_REMOVE_IF_UNREFERENCED const DEVICE_PATH_TO_TEXT_GENERIC_TABLE mUefiDevicePathLibToTextTableGeneric[] = {
2094   {HARDWARE_DEVICE_PATH,  L"HardwarePath"   },
2095   {ACPI_DEVICE_PATH,      L"AcpiPath"       },
2096   {MESSAGING_DEVICE_PATH, L"Msg"            },
2097   {MEDIA_DEVICE_PATH,     L"MediaPath"      },
2098   {BBS_DEVICE_PATH,       L"BbsPath"        },
2099   {0, NULL}
2100 };
2101
2102 /**
2103   Converts an unknown device path structure to its string representative.
2104
2105   @param Str             The string representative of input device.
2106   @param DevPath         The input device path structure.
2107   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
2108                          of the display node is used, where applicable. If DisplayOnly
2109                          is FALSE, then the longer text representation of the display node
2110                          is used.
2111   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
2112                          representation for a device node can be used, where applicable.
2113
2114 **/
2115 VOID
2116 DevPathToTextNodeGeneric (
2117   IN OUT POOL_PRINT  *Str,
2118   IN VOID            *DevPath,
2119   IN BOOLEAN         DisplayOnly,
2120   IN BOOLEAN         AllowShortcuts
2121   )
2122 {
2123   EFI_DEVICE_PATH_PROTOCOL *Node;
2124   UINTN                    Index;
2125
2126   Node = DevPath;
2127
2128   for (Index = 0; mUefiDevicePathLibToTextTableGeneric[Index].Text != NULL; Index++) {
2129     if (DevicePathType (Node) == mUefiDevicePathLibToTextTableGeneric[Index].Type) {
2130       break;
2131     }
2132   }
2133
2134   if (mUefiDevicePathLibToTextTableGeneric[Index].Text == NULL) {
2135     //
2136     // It's a node whose type cannot be recognized
2137     //
2138     UefiDevicePathLibCatPrint (Str, L"Path(%d,%d", DevicePathType (Node), DevicePathSubType (Node));
2139   } else {
2140     //
2141     // It's a node whose type can be recognized
2142     //
2143     UefiDevicePathLibCatPrint (Str, L"%s(%d", mUefiDevicePathLibToTextTableGeneric[Index].Text, DevicePathSubType (Node));
2144   }
2145
2146   Index = sizeof (EFI_DEVICE_PATH_PROTOCOL);
2147   if (Index < DevicePathNodeLength (Node)) {
2148     UefiDevicePathLibCatPrint (Str, L",");
2149     for (; Index < DevicePathNodeLength (Node); Index++) {
2150       UefiDevicePathLibCatPrint (Str, L"%02x", ((UINT8 *) Node)[Index]);
2151     }
2152   }
2153
2154   UefiDevicePathLibCatPrint (Str, L")");
2155 }
2156
2157 GLOBAL_REMOVE_IF_UNREFERENCED const DEVICE_PATH_TO_TEXT_TABLE mUefiDevicePathLibToTextTable[] = {
2158   {HARDWARE_DEVICE_PATH,  HW_PCI_DP,                        DevPathToTextPci            },
2159   {HARDWARE_DEVICE_PATH,  HW_PCCARD_DP,                     DevPathToTextPccard         },
2160   {HARDWARE_DEVICE_PATH,  HW_MEMMAP_DP,                     DevPathToTextMemMap         },
2161   {HARDWARE_DEVICE_PATH,  HW_VENDOR_DP,                     DevPathToTextVendor         },
2162   {HARDWARE_DEVICE_PATH,  HW_CONTROLLER_DP,                 DevPathToTextController     },
2163   {HARDWARE_DEVICE_PATH,  HW_BMC_DP,                        DevPathToTextBmc            },
2164   {ACPI_DEVICE_PATH,      ACPI_DP,                          DevPathToTextAcpi           },
2165   {ACPI_DEVICE_PATH,      ACPI_EXTENDED_DP,                 DevPathToTextAcpiEx         },
2166   {ACPI_DEVICE_PATH,      ACPI_ADR_DP,                      DevPathToTextAcpiAdr        },
2167   {MESSAGING_DEVICE_PATH, MSG_ATAPI_DP,                     DevPathToTextAtapi          },
2168   {MESSAGING_DEVICE_PATH, MSG_SCSI_DP,                      DevPathToTextScsi           },
2169   {MESSAGING_DEVICE_PATH, MSG_FIBRECHANNEL_DP,              DevPathToTextFibre          },
2170   {MESSAGING_DEVICE_PATH, MSG_FIBRECHANNELEX_DP,            DevPathToTextFibreEx        },
2171   {MESSAGING_DEVICE_PATH, MSG_SASEX_DP,                     DevPathToTextSasEx          },
2172   {MESSAGING_DEVICE_PATH, MSG_NVME_NAMESPACE_DP,            DevPathToTextNVMe           },
2173   {MESSAGING_DEVICE_PATH, MSG_UFS_DP,                       DevPathToTextUfs            },
2174   {MESSAGING_DEVICE_PATH, MSG_SD_DP,                        DevPathToTextSd             },
2175   {MESSAGING_DEVICE_PATH, MSG_EMMC_DP,                      DevPathToTextEmmc           },
2176   {MESSAGING_DEVICE_PATH, MSG_1394_DP,                      DevPathToText1394           },
2177   {MESSAGING_DEVICE_PATH, MSG_USB_DP,                       DevPathToTextUsb            },
2178   {MESSAGING_DEVICE_PATH, MSG_USB_WWID_DP,                  DevPathToTextUsbWWID        },
2179   {MESSAGING_DEVICE_PATH, MSG_DEVICE_LOGICAL_UNIT_DP,       DevPathToTextLogicalUnit    },
2180   {MESSAGING_DEVICE_PATH, MSG_USB_CLASS_DP,                 DevPathToTextUsbClass       },
2181   {MESSAGING_DEVICE_PATH, MSG_SATA_DP,                      DevPathToTextSata           },
2182   {MESSAGING_DEVICE_PATH, MSG_I2O_DP,                       DevPathToTextI2O            },
2183   {MESSAGING_DEVICE_PATH, MSG_MAC_ADDR_DP,                  DevPathToTextMacAddr        },
2184   {MESSAGING_DEVICE_PATH, MSG_IPv4_DP,                      DevPathToTextIPv4           },
2185   {MESSAGING_DEVICE_PATH, MSG_IPv6_DP,                      DevPathToTextIPv6           },
2186   {MESSAGING_DEVICE_PATH, MSG_INFINIBAND_DP,                DevPathToTextInfiniBand     },
2187   {MESSAGING_DEVICE_PATH, MSG_UART_DP,                      DevPathToTextUart           },
2188   {MESSAGING_DEVICE_PATH, MSG_VENDOR_DP,                    DevPathToTextVendor         },
2189   {MESSAGING_DEVICE_PATH, MSG_ISCSI_DP,                     DevPathToTextiSCSI          },
2190   {MESSAGING_DEVICE_PATH, MSG_VLAN_DP,                      DevPathToTextVlan           },
2191   {MESSAGING_DEVICE_PATH, MSG_URI_DP,                       DevPathToTextUri            },
2192   {MESSAGING_DEVICE_PATH, MSG_BLUETOOTH_DP,                 DevPathToTextBluetooth      },
2193   {MESSAGING_DEVICE_PATH, MSG_WIFI_DP,                      DevPathToTextWiFi           },
2194   {MEDIA_DEVICE_PATH,     MEDIA_HARDDRIVE_DP,               DevPathToTextHardDrive      },
2195   {MEDIA_DEVICE_PATH,     MEDIA_CDROM_DP,                   DevPathToTextCDROM          },
2196   {MEDIA_DEVICE_PATH,     MEDIA_VENDOR_DP,                  DevPathToTextVendor         },
2197   {MEDIA_DEVICE_PATH,     MEDIA_PROTOCOL_DP,                DevPathToTextMediaProtocol  },
2198   {MEDIA_DEVICE_PATH,     MEDIA_FILEPATH_DP,                DevPathToTextFilePath       },
2199   {MEDIA_DEVICE_PATH,     MEDIA_PIWG_FW_VOL_DP,             DevPathToTextFv             },
2200   {MEDIA_DEVICE_PATH,     MEDIA_PIWG_FW_FILE_DP,            DevPathToTextFvFile         },
2201   {MEDIA_DEVICE_PATH,     MEDIA_RELATIVE_OFFSET_RANGE_DP,   DevPathRelativeOffsetRange  },
2202   {MEDIA_DEVICE_PATH,     MEDIA_RAM_DISK_DP,                DevPathToTextRamDisk        },
2203   {BBS_DEVICE_PATH,       BBS_BBS_DP,                       DevPathToTextBBS            },
2204   {END_DEVICE_PATH_TYPE,  END_INSTANCE_DEVICE_PATH_SUBTYPE, DevPathToTextEndInstance    },
2205   {0, 0, NULL}
2206 };
2207
2208 /**
2209   Converts a device node to its string representation.
2210
2211   @param DeviceNode        A Pointer to the device node to be converted.
2212   @param DisplayOnly       If DisplayOnly is TRUE, then the shorter text representation
2213                            of the display node is used, where applicable. If DisplayOnly
2214                            is FALSE, then the longer text representation of the display node
2215                            is used.
2216   @param AllowShortcuts    If AllowShortcuts is TRUE, then the shortcut forms of text
2217                            representation for a device node can be used, where applicable.
2218
2219   @return A pointer to the allocated text representation of the device node or NULL if DeviceNode
2220           is NULL or there was insufficient memory.
2221
2222 **/
2223 CHAR16 *
2224 EFIAPI
2225 UefiDevicePathLibConvertDeviceNodeToText (
2226   IN CONST EFI_DEVICE_PATH_PROTOCOL  *DeviceNode,
2227   IN BOOLEAN                         DisplayOnly,
2228   IN BOOLEAN                         AllowShortcuts
2229   )
2230 {
2231   POOL_PRINT          Str;
2232   UINTN               Index;
2233   DEVICE_PATH_TO_TEXT ToText;
2234
2235   if (DeviceNode == NULL) {
2236     return NULL;
2237   }
2238
2239   ZeroMem (&Str, sizeof (Str));
2240
2241   //
2242   // Process the device path node
2243   // If not found, use a generic function
2244   //
2245   ToText = DevPathToTextNodeGeneric;
2246   for (Index = 0; mUefiDevicePathLibToTextTable[Index].Function != NULL; Index++) {
2247     if (DevicePathType (DeviceNode) == mUefiDevicePathLibToTextTable[Index].Type &&
2248         DevicePathSubType (DeviceNode) == mUefiDevicePathLibToTextTable[Index].SubType
2249         ) {
2250       ToText = mUefiDevicePathLibToTextTable[Index].Function;
2251       break;
2252     }
2253   }
2254
2255   //
2256   // Print this node
2257   //
2258   ToText (&Str, (VOID *) DeviceNode, DisplayOnly, AllowShortcuts);
2259
2260   ASSERT (Str.Str != NULL);
2261   return Str.Str;
2262 }
2263
2264 /**
2265   Converts a device path to its text representation.
2266
2267   @param DevicePath      A Pointer to the device to be converted.
2268   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
2269                          of the display node is used, where applicable. If DisplayOnly
2270                          is FALSE, then the longer text representation of the display node
2271                          is used.
2272   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
2273                          representation for a device node can be used, where applicable.
2274
2275   @return A pointer to the allocated text representation of the device path or
2276           NULL if DeviceNode is NULL or there was insufficient memory.
2277
2278 **/
2279 CHAR16 *
2280 EFIAPI
2281 UefiDevicePathLibConvertDevicePathToText (
2282   IN CONST EFI_DEVICE_PATH_PROTOCOL   *DevicePath,
2283   IN BOOLEAN                          DisplayOnly,
2284   IN BOOLEAN                          AllowShortcuts
2285   )
2286 {
2287   POOL_PRINT               Str;
2288   EFI_DEVICE_PATH_PROTOCOL *Node;
2289   EFI_DEVICE_PATH_PROTOCOL *AlignedNode;
2290   UINTN                    Index;
2291   DEVICE_PATH_TO_TEXT      ToText;
2292
2293   if (DevicePath == NULL) {
2294     return NULL;
2295   }
2296
2297   ZeroMem (&Str, sizeof (Str));
2298
2299   //
2300   // Process each device path node
2301   //
2302   Node = (EFI_DEVICE_PATH_PROTOCOL *) DevicePath;
2303   while (!IsDevicePathEnd (Node)) {
2304     //
2305     // Find the handler to dump this device path node
2306     // If not found, use a generic function
2307     //
2308     ToText = DevPathToTextNodeGeneric;
2309     for (Index = 0; mUefiDevicePathLibToTextTable[Index].Function != NULL; Index += 1) {
2310
2311       if (DevicePathType (Node) == mUefiDevicePathLibToTextTable[Index].Type &&
2312           DevicePathSubType (Node) == mUefiDevicePathLibToTextTable[Index].SubType
2313           ) {
2314         ToText = mUefiDevicePathLibToTextTable[Index].Function;
2315         break;
2316       }
2317     }
2318     //
2319     //  Put a path separator in if needed
2320     //
2321     if ((Str.Count != 0) && (ToText != DevPathToTextEndInstance)) {
2322       if (Str.Str[Str.Count] != L',') {
2323         UefiDevicePathLibCatPrint (&Str, L"/");
2324       }
2325     }
2326
2327     AlignedNode = AllocateCopyPool (DevicePathNodeLength (Node), Node);
2328     //
2329     // Print this node of the device path
2330     //
2331     ToText (&Str, AlignedNode, DisplayOnly, AllowShortcuts);
2332     FreePool (AlignedNode);
2333
2334     //
2335     // Next device path node
2336     //
2337     Node = NextDevicePathNode (Node);
2338   }
2339
2340   if (Str.Str == NULL) {
2341     return AllocateZeroPool (sizeof (CHAR16));
2342   } else {
2343     return Str.Str;
2344   }
2345 }