lib/libefivar/efivar-dp-format.c

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