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 = AllocateCopyPool ((Length + 1) * sizeof (CHAR16), SerialNumberStr);
1053     ASSERT (NewStr != NULL);
1054     NewStr[Length]  = 0;
1055     SerialNumberStr = NewStr;
1056   }
1057
1058   UefiDevicePathLibCatPrint (
1059     Str,
1060     "UsbWwid(0x%x,0x%x,0x%x,\"%S\")",
1061     UsbWWId->VendorId,
1062     UsbWWId->ProductId,
1063     UsbWWId->InterfaceNumber,
1064     SerialNumberStr
1065     );
1066 }
1067
1068 /**
1069   Converts a Logic Unit device path structure to its string representative.
1070
1071   @param Str             The string representative of input device.
1072   @param DevPath         The input device path structure.
1073   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1074                          of the display node is used, where applicable. If DisplayOnly
1075                          is FALSE, then the longer text representation of the display node
1076                          is used.
1077   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1078                          representation for a device node can be used, where applicable.
1079
1080 **/
1081 static VOID
1082 DevPathToTextLogicalUnit (
1083   IN OUT POOL_PRINT  *Str,
1084   IN VOID            *DevPath,
1085   IN BOOLEAN         DisplayOnly,
1086   IN BOOLEAN         AllowShortcuts
1087   )
1088 {
1089   DEVICE_LOGICAL_UNIT_DEVICE_PATH  *LogicalUnit;
1090
1091   LogicalUnit = DevPath;
1092   UefiDevicePathLibCatPrint (Str, "Unit(0x%x)", LogicalUnit->Lun);
1093 }
1094
1095 /**
1096   Converts a USB class device path structure to its string representative.
1097
1098   @param Str             The string representative of input device.
1099   @param DevPath         The input device path structure.
1100   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1101                          of the display node is used, where applicable. If DisplayOnly
1102                          is FALSE, then the longer text representation of the display node
1103                          is used.
1104   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1105                          representation for a device node can be used, where applicable.
1106
1107 **/
1108 static VOID
1109 DevPathToTextUsbClass (
1110   IN OUT POOL_PRINT  *Str,
1111   IN VOID            *DevPath,
1112   IN BOOLEAN         DisplayOnly,
1113   IN BOOLEAN         AllowShortcuts
1114   )
1115 {
1116   USB_CLASS_DEVICE_PATH  *UsbClass;
1117   BOOLEAN                IsKnownSubClass;
1118
1119   UsbClass = DevPath;
1120
1121   IsKnownSubClass = TRUE;
1122   switch (UsbClass->DeviceClass) {
1123     case USB_CLASS_AUDIO:
1124       UefiDevicePathLibCatPrint (Str, "UsbAudio");
1125       break;
1126
1127     case USB_CLASS_CDCCONTROL:
1128       UefiDevicePathLibCatPrint (Str, "UsbCDCControl");
1129       break;
1130
1131     case USB_CLASS_HID:
1132       UefiDevicePathLibCatPrint (Str, "UsbHID");
1133       break;
1134
1135     case USB_CLASS_IMAGE:
1136       UefiDevicePathLibCatPrint (Str, "UsbImage");
1137       break;
1138
1139     case USB_CLASS_PRINTER:
1140       UefiDevicePathLibCatPrint (Str, "UsbPrinter");
1141       break;
1142
1143     case USB_CLASS_MASS_STORAGE:
1144       UefiDevicePathLibCatPrint (Str, "UsbMassStorage");
1145       break;
1146
1147     case USB_CLASS_HUB:
1148       UefiDevicePathLibCatPrint (Str, "UsbHub");
1149       break;
1150
1151     case USB_CLASS_CDCDATA:
1152       UefiDevicePathLibCatPrint (Str, "UsbCDCData");
1153       break;
1154
1155     case USB_CLASS_SMART_CARD:
1156       UefiDevicePathLibCatPrint (Str, "UsbSmartCard");
1157       break;
1158
1159     case USB_CLASS_VIDEO:
1160       UefiDevicePathLibCatPrint (Str, "UsbVideo");
1161       break;
1162
1163     case USB_CLASS_DIAGNOSTIC:
1164       UefiDevicePathLibCatPrint (Str, "UsbDiagnostic");
1165       break;
1166
1167     case USB_CLASS_WIRELESS:
1168       UefiDevicePathLibCatPrint (Str, "UsbWireless");
1169       break;
1170
1171     default:
1172       IsKnownSubClass = FALSE;
1173       break;
1174   }
1175
1176   if (IsKnownSubClass) {
1177     UefiDevicePathLibCatPrint (
1178       Str,
1179       "(0x%x,0x%x,0x%x,0x%x)",
1180       UsbClass->VendorId,
1181       UsbClass->ProductId,
1182       UsbClass->DeviceSubClass,
1183       UsbClass->DeviceProtocol
1184       );
1185     return;
1186   }
1187
1188   if (UsbClass->DeviceClass == USB_CLASS_RESERVE) {
1189     if (UsbClass->DeviceSubClass == USB_SUBCLASS_FW_UPDATE) {
1190       UefiDevicePathLibCatPrint (
1191         Str,
1192         "UsbDeviceFirmwareUpdate(0x%x,0x%x,0x%x)",
1193         UsbClass->VendorId,
1194         UsbClass->ProductId,
1195         UsbClass->DeviceProtocol
1196         );
1197       return;
1198     } else if (UsbClass->DeviceSubClass == USB_SUBCLASS_IRDA_BRIDGE) {
1199       UefiDevicePathLibCatPrint (
1200         Str,
1201         "UsbIrdaBridge(0x%x,0x%x,0x%x)",
1202         UsbClass->VendorId,
1203         UsbClass->ProductId,
1204         UsbClass->DeviceProtocol
1205         );
1206       return;
1207     } else if (UsbClass->DeviceSubClass == USB_SUBCLASS_TEST) {
1208       UefiDevicePathLibCatPrint (
1209         Str,
1210         "UsbTestAndMeasurement(0x%x,0x%x,0x%x)",
1211         UsbClass->VendorId,
1212         UsbClass->ProductId,
1213         UsbClass->DeviceProtocol
1214         );
1215       return;
1216     }
1217   }
1218
1219   UefiDevicePathLibCatPrint (
1220     Str,
1221     "UsbClass(0x%x,0x%x,0x%x,0x%x,0x%x)",
1222     UsbClass->VendorId,
1223     UsbClass->ProductId,
1224     UsbClass->DeviceClass,
1225     UsbClass->DeviceSubClass,
1226     UsbClass->DeviceProtocol
1227     );
1228 }
1229
1230 /**
1231   Converts a SATA device path structure to its string representative.
1232
1233   @param Str             The string representative of input device.
1234   @param DevPath         The input device path structure.
1235   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1236                          of the display node is used, where applicable. If DisplayOnly
1237                          is FALSE, then the longer text representation of the display node
1238                          is used.
1239   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1240                          representation for a device node can be used, where applicable.
1241
1242 **/
1243 static VOID
1244 DevPathToTextSata (
1245   IN OUT POOL_PRINT  *Str,
1246   IN VOID            *DevPath,
1247   IN BOOLEAN         DisplayOnly,
1248   IN BOOLEAN         AllowShortcuts
1249   )
1250 {
1251   SATA_DEVICE_PATH  *Sata;
1252
1253   Sata = DevPath;
1254   UefiDevicePathLibCatPrint (
1255     Str,
1256     "Sata(0x%x,0x%x,0x%x)",
1257     Sata->HBAPortNumber,
1258     Sata->PortMultiplierPortNumber,
1259     Sata->Lun
1260     );
1261 }
1262
1263 /**
1264   Converts a I20 device path structure to its string representative.
1265
1266   @param Str             The string representative of input device.
1267   @param DevPath         The input device path structure.
1268   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1269                          of the display node is used, where applicable. If DisplayOnly
1270                          is FALSE, then the longer text representation of the display node
1271                          is used.
1272   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1273                          representation for a device node can be used, where applicable.
1274
1275 **/
1276 static VOID
1277 DevPathToTextI2O (
1278   IN OUT POOL_PRINT  *Str,
1279   IN VOID            *DevPath,
1280   IN BOOLEAN         DisplayOnly,
1281   IN BOOLEAN         AllowShortcuts
1282   )
1283 {
1284   I2O_DEVICE_PATH  *I2ODevPath;
1285
1286   I2ODevPath = DevPath;
1287   UefiDevicePathLibCatPrint (Str, "I2O(0x%x)", I2ODevPath->Tid);
1288 }
1289
1290 /**
1291   Converts a MAC address device path structure to its string representative.
1292
1293   @param Str             The string representative of input device.
1294   @param DevPath         The input device path structure.
1295   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1296                          of the display node is used, where applicable. If DisplayOnly
1297                          is FALSE, then the longer text representation of the display node
1298                          is used.
1299   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1300                          representation for a device node can be used, where applicable.
1301
1302 **/
1303 static VOID
1304 DevPathToTextMacAddr (
1305   IN OUT POOL_PRINT  *Str,
1306   IN VOID            *DevPath,
1307   IN BOOLEAN         DisplayOnly,
1308   IN BOOLEAN         AllowShortcuts
1309   )
1310 {
1311   MAC_ADDR_DEVICE_PATH  *MacDevPath;
1312   UINTN                 HwAddressSize;
1313   UINTN                 Index;
1314
1315   MacDevPath = DevPath;
1316
1317   HwAddressSize = sizeof (EFI_MAC_ADDRESS);
1318   if ((MacDevPath->IfType == 0x01) || (MacDevPath->IfType == 0x00)) {
1319     HwAddressSize = 6;
1320   }
1321
1322   UefiDevicePathLibCatPrint (Str, "MAC(");
1323
1324   for (Index = 0; Index < HwAddressSize; Index++) {
1325     UefiDevicePathLibCatPrint (Str, "%02x", MacDevPath->MacAddress.Addr[Index]);
1326   }
1327
1328   UefiDevicePathLibCatPrint (Str, ",0x%x)", MacDevPath->IfType);
1329 }
1330
1331 /**
1332   Converts network protocol string to its text representation.
1333
1334   @param Str             The string representative of input device.
1335   @param Protocol        The network protocol ID.
1336
1337 **/
1338 static VOID
1339 CatNetworkProtocol (
1340   IN OUT POOL_PRINT  *Str,
1341   IN UINT16          Protocol
1342   )
1343 {
1344   if (Protocol == RFC_1700_TCP_PROTOCOL) {
1345     UefiDevicePathLibCatPrint (Str, "TCP");
1346   } else if (Protocol == RFC_1700_UDP_PROTOCOL) {
1347     UefiDevicePathLibCatPrint (Str, "UDP");
1348   } else {
1349     UefiDevicePathLibCatPrint (Str, "0x%x", Protocol);
1350   }
1351 }
1352
1353 /**
1354   Converts IP v4 address to its text representation.
1355
1356   @param Str             The string representative of input device.
1357   @param Address         The IP v4 address.
1358 **/
1359 static VOID
1360 CatIPv4Address (
1361   IN OUT POOL_PRINT    *Str,
1362   IN EFI_IPv4_ADDRESS  *Address
1363   )
1364 {
1365   UefiDevicePathLibCatPrint (Str, "%d.%d.%d.%d", Address->Addr[0], Address->Addr[1], Address->Addr[2], Address->Addr[3]);
1366 }
1367
1368 /**
1369   Converts IP v6 address to its text representation.
1370
1371   @param Str             The string representative of input device.
1372   @param Address         The IP v6 address.
1373 **/
1374 static VOID
1375 CatIPv6Address (
1376   IN OUT POOL_PRINT    *Str,
1377   IN EFI_IPv6_ADDRESS  *Address
1378   )
1379 {
1380   UefiDevicePathLibCatPrint (
1381     Str,
1382     "%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x",
1383     Address->Addr[0],
1384     Address->Addr[1],
1385     Address->Addr[2],
1386     Address->Addr[3],
1387     Address->Addr[4],
1388     Address->Addr[5],
1389     Address->Addr[6],
1390     Address->Addr[7],
1391     Address->Addr[8],
1392     Address->Addr[9],
1393     Address->Addr[10],
1394     Address->Addr[11],
1395     Address->Addr[12],
1396     Address->Addr[13],
1397     Address->Addr[14],
1398     Address->Addr[15]
1399     );
1400 }
1401
1402 /**
1403   Converts a IPv4 device path structure to its string representative.
1404
1405   @param Str             The string representative of input device.
1406   @param DevPath         The input device path structure.
1407   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1408                          of the display node is used, where applicable. If DisplayOnly
1409                          is FALSE, then the longer text representation of the display node
1410                          is used.
1411   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1412                          representation for a device node can be used, where applicable.
1413
1414 **/
1415 static VOID
1416 DevPathToTextIPv4 (
1417   IN OUT POOL_PRINT  *Str,
1418   IN VOID            *DevPath,
1419   IN BOOLEAN         DisplayOnly,
1420   IN BOOLEAN         AllowShortcuts
1421   )
1422 {
1423   IPv4_DEVICE_PATH  *IPDevPath;
1424
1425   IPDevPath = DevPath;
1426   UefiDevicePathLibCatPrint (Str, "IPv4(");
1427   CatIPv4Address (Str, &IPDevPath->RemoteIpAddress);
1428
1429   if (DisplayOnly) {
1430     UefiDevicePathLibCatPrint (Str, ")");
1431     return;
1432   }
1433
1434   UefiDevicePathLibCatPrint (Str, ",");
1435   CatNetworkProtocol (Str, IPDevPath->Protocol);
1436
1437   UefiDevicePathLibCatPrint (Str, ",%s,", IPDevPath->StaticIpAddress ? "Static" : "DHCP");
1438   CatIPv4Address (Str, &IPDevPath->LocalIpAddress);
1439   if (DevicePathNodeLength (IPDevPath) == sizeof (IPv4_DEVICE_PATH)) {
1440     UefiDevicePathLibCatPrint (Str, ",");
1441     CatIPv4Address (Str, &IPDevPath->GatewayIpAddress);
1442     UefiDevicePathLibCatPrint (Str, ",");
1443     CatIPv4Address (Str, &IPDevPath->SubnetMask);
1444   }
1445
1446   UefiDevicePathLibCatPrint (Str, ")");
1447 }
1448
1449 /**
1450   Converts a IPv6 device path structure to its string representative.
1451
1452   @param Str             The string representative of input device.
1453   @param DevPath         The input device path structure.
1454   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1455                          of the display node is used, where applicable. If DisplayOnly
1456                          is FALSE, then the longer text representation of the display node
1457                          is used.
1458   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1459                          representation for a device node can be used, where applicable.
1460
1461 **/
1462 static VOID
1463 DevPathToTextIPv6 (
1464   IN OUT POOL_PRINT  *Str,
1465   IN VOID            *DevPath,
1466   IN BOOLEAN         DisplayOnly,
1467   IN BOOLEAN         AllowShortcuts
1468   )
1469 {
1470   IPv6_DEVICE_PATH  *IPDevPath;
1471
1472   IPDevPath = DevPath;
1473   UefiDevicePathLibCatPrint (Str, "IPv6(");
1474   CatIPv6Address (Str, &IPDevPath->RemoteIpAddress);
1475   if (DisplayOnly) {
1476     UefiDevicePathLibCatPrint (Str, ")");
1477     return;
1478   }
1479
1480   UefiDevicePathLibCatPrint (Str, ",");
1481   CatNetworkProtocol (Str, IPDevPath->Protocol);
1482
1483   switch (IPDevPath->IpAddressOrigin) {
1484     case 0:
1485       UefiDevicePathLibCatPrint (Str, ",Static,");
1486       break;
1487     case 1:
1488       UefiDevicePathLibCatPrint (Str, ",StatelessAutoConfigure,");
1489       break;
1490     default:
1491       UefiDevicePathLibCatPrint (Str, ",StatefulAutoConfigure,");
1492       break;
1493   }
1494
1495   CatIPv6Address (Str, &IPDevPath->LocalIpAddress);
1496
1497   if (DevicePathNodeLength (IPDevPath) == sizeof (IPv6_DEVICE_PATH)) {
1498     UefiDevicePathLibCatPrint (Str, ",0x%x,", IPDevPath->PrefixLength);
1499     CatIPv6Address (Str, &IPDevPath->GatewayIpAddress);
1500   }
1501
1502   UefiDevicePathLibCatPrint (Str, ")");
1503 }
1504
1505 /**
1506   Converts an Infini Band device path structure to its string representative.
1507
1508   @param Str             The string representative of input device.
1509   @param DevPath         The input device path structure.
1510   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1511                          of the display node is used, where applicable. If DisplayOnly
1512                          is FALSE, then the longer text representation of the display node
1513                          is used.
1514   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1515                          representation for a device node can be used, where applicable.
1516
1517 **/
1518 static VOID
1519 DevPathToTextInfiniBand (
1520   IN OUT POOL_PRINT  *Str,
1521   IN VOID            *DevPath,
1522   IN BOOLEAN         DisplayOnly,
1523   IN BOOLEAN         AllowShortcuts
1524   )
1525 {
1526   INFINIBAND_DEVICE_PATH  *InfiniBand;
1527
1528   InfiniBand = DevPath;
1529   UefiDevicePathLibCatPrint (
1530     Str,
1531     "Infiniband(0x%x,%36s,0x%lx,0x%lx,0x%lx)",
1532     InfiniBand->ResourceFlags,
1533     G(InfiniBand->PortGid),
1534     InfiniBand->ServiceId,
1535     InfiniBand->TargetPortId,
1536     InfiniBand->DeviceId
1537     );
1538 }
1539
1540 /**
1541   Converts a UART device path structure to its string representative.
1542
1543   @param Str             The string representative of input device.
1544   @param DevPath         The input device path structure.
1545   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1546                          of the display node is used, where applicable. If DisplayOnly
1547                          is FALSE, then the longer text representation of the display node
1548                          is used.
1549   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1550                          representation for a device node can be used, where applicable.
1551
1552 **/
1553 static VOID
1554 DevPathToTextUart (
1555   IN OUT POOL_PRINT  *Str,
1556   IN VOID            *DevPath,
1557   IN BOOLEAN         DisplayOnly,
1558   IN BOOLEAN         AllowShortcuts
1559   )
1560 {
1561   UART_DEVICE_PATH  *Uart;
1562   CHAR8             Parity;
1563
1564   Uart = DevPath;
1565   switch (Uart->Parity) {
1566     case 0:
1567       Parity = 'D';
1568       break;
1569
1570     case 1:
1571       Parity = 'N';
1572       break;
1573
1574     case 2:
1575       Parity = 'E';
1576       break;
1577
1578     case 3:
1579       Parity = 'O';
1580       break;
1581
1582     case 4:
1583       Parity = 'M';
1584       break;
1585
1586     case 5:
1587       Parity = 'S';
1588       break;
1589
1590     default:
1591       Parity = 'x';
1592       break;
1593   }
1594
1595   if (Uart->BaudRate == 0) {
1596     UefiDevicePathLibCatPrint (Str, "Uart(DEFAULT,");
1597   } else {
1598     UefiDevicePathLibCatPrint (Str, "Uart(%ld,", Uart->BaudRate);
1599   }
1600
1601   if (Uart->DataBits == 0) {
1602     UefiDevicePathLibCatPrint (Str, "DEFAULT,");
1603   } else {
1604     UefiDevicePathLibCatPrint (Str, "%d,", Uart->DataBits);
1605   }
1606
1607   UefiDevicePathLibCatPrint (Str, "%c,", Parity);
1608
1609   switch (Uart->StopBits) {
1610     case 0:
1611       UefiDevicePathLibCatPrint (Str, "D)");
1612       break;
1613
1614     case 1:
1615       UefiDevicePathLibCatPrint (Str, "1)");
1616       break;
1617
1618     case 2:
1619       UefiDevicePathLibCatPrint (Str, "1.5)");
1620       break;
1621
1622     case 3:
1623       UefiDevicePathLibCatPrint (Str, "2)");
1624       break;
1625
1626     default:
1627       UefiDevicePathLibCatPrint (Str, "x)");
1628       break;
1629   }
1630 }
1631
1632 /**
1633   Converts an iSCSI device path structure to its string representative.
1634
1635   @param Str             The string representative of input device.
1636   @param DevPath         The input device path structure.
1637   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1638                          of the display node is used, where applicable. If DisplayOnly
1639                          is FALSE, then the longer text representation of the display node
1640                          is used.
1641   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1642                          representation for a device node can be used, where applicable.
1643
1644 **/
1645 static VOID
1646 DevPathToTextiSCSI (
1647   IN OUT POOL_PRINT  *Str,
1648   IN VOID            *DevPath,
1649   IN BOOLEAN         DisplayOnly,
1650   IN BOOLEAN         AllowShortcuts
1651   )
1652 {
1653   ISCSI_DEVICE_PATH_WITH_NAME  *ISCSIDevPath;
1654   UINT16                       Options;
1655   UINTN                        Index;
1656
1657   ISCSIDevPath = DevPath;
1658   UefiDevicePathLibCatPrint (
1659     Str,
1660     "iSCSI(%s,0x%x,0x",
1661     ISCSIDevPath->TargetName,
1662     ISCSIDevPath->TargetPortalGroupTag
1663     );
1664   for (Index = 0; Index < sizeof (ISCSIDevPath->Lun) / sizeof (UINT8); Index++) {
1665     UefiDevicePathLibCatPrint (Str, "%02x", ((UINT8 *)&ISCSIDevPath->Lun)[Index]);
1666   }
1667
1668   Options = ISCSIDevPath->LoginOption;
1669   UefiDevicePathLibCatPrint (Str, ",%s,", (((Options >> 1) & 0x0001) != 0) ? "CRC32C" : "None");
1670   UefiDevicePathLibCatPrint (Str, "%s,", (((Options >> 3) & 0x0001) != 0) ? "CRC32C" : "None");
1671   if (((Options >> 11) & 0x0001) != 0) {
1672     UefiDevicePathLibCatPrint (Str, "%s,", "None");
1673   } else if (((Options >> 12) & 0x0001) != 0) {
1674     UefiDevicePathLibCatPrint (Str, "%s,", "CHAP_UNI");
1675   } else {
1676     UefiDevicePathLibCatPrint (Str, "%s,", "CHAP_BI");
1677   }
1678
1679   UefiDevicePathLibCatPrint (Str, "%s)", (ISCSIDevPath->NetworkProtocol == 0) ? "TCP" : "reserved");
1680 }
1681
1682 /**
1683   Converts a VLAN device path structure to its string representative.
1684
1685   @param Str             The string representative of input device.
1686   @param DevPath         The input device path structure.
1687   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1688                          of the display node is used, where applicable. If DisplayOnly
1689                          is FALSE, then the longer text representation of the display node
1690                          is used.
1691   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1692                          representation for a device node can be used, where applicable.
1693
1694 **/
1695 static VOID
1696 DevPathToTextVlan (
1697   IN OUT POOL_PRINT  *Str,
1698   IN VOID            *DevPath,
1699   IN BOOLEAN         DisplayOnly,
1700   IN BOOLEAN         AllowShortcuts
1701   )
1702 {
1703   VLAN_DEVICE_PATH  *Vlan;
1704
1705   Vlan = DevPath;
1706   UefiDevicePathLibCatPrint (Str, "Vlan(%d)", Vlan->VlanId);
1707 }
1708
1709 /**
1710   Converts a Bluetooth device path structure to its string representative.
1711
1712   @param Str             The string representative of input device.
1713   @param DevPath         The input device path structure.
1714   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1715                          of the display node is used, where applicable. If DisplayOnly
1716                          is FALSE, then the longer text representation of the display node
1717                          is used.
1718   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1719                          representation for a device node can be used, where applicable.
1720
1721 **/
1722 static VOID
1723 DevPathToTextBluetooth (
1724   IN OUT POOL_PRINT  *Str,
1725   IN VOID            *DevPath,
1726   IN BOOLEAN         DisplayOnly,
1727   IN BOOLEAN         AllowShortcuts
1728   )
1729 {
1730   BLUETOOTH_DEVICE_PATH  *Bluetooth;
1731
1732   Bluetooth = DevPath;
1733   UefiDevicePathLibCatPrint (
1734     Str,
1735     "Bluetooth(%02x%02x%02x%02x%02x%02x)",
1736     Bluetooth->BD_ADDR.Address[0],
1737     Bluetooth->BD_ADDR.Address[1],
1738     Bluetooth->BD_ADDR.Address[2],
1739     Bluetooth->BD_ADDR.Address[3],
1740     Bluetooth->BD_ADDR.Address[4],
1741     Bluetooth->BD_ADDR.Address[5]
1742     );
1743 }
1744
1745 /**
1746   Converts a Wi-Fi device path structure to its string representative.
1747
1748   @param Str             The string representative of input device.
1749   @param DevPath         The input device path structure.
1750   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1751                          of the display node is used, where applicable. If DisplayOnly
1752                          is FALSE, then the longer text representation of the display node
1753                          is used.
1754   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1755                          representation for a device node can be used, where applicable.
1756
1757 **/
1758 static VOID
1759 DevPathToTextWiFi (
1760   IN OUT POOL_PRINT  *Str,
1761   IN VOID            *DevPath,
1762   IN BOOLEAN         DisplayOnly,
1763   IN BOOLEAN         AllowShortcuts
1764   )
1765 {
1766   WIFI_DEVICE_PATH  *WiFi;
1767   UINT8             SSId[33];
1768
1769   WiFi = DevPath;
1770
1771   SSId[32] = '\0';
1772   CopyMem (SSId, WiFi->SSId, 32);
1773
1774   UefiDevicePathLibCatPrint (Str, "Wi-Fi(%s)", SSId);
1775 }
1776
1777 /**
1778   Converts a Bluetooth device path structure to its string representative.
1779
1780   @param Str             The string representative of input device.
1781   @param DevPath         The input device path structure.
1782   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1783                          of the display node is used, where applicable. If DisplayOnly
1784                          is FALSE, then the longer text representation of the display node
1785                          is used.
1786   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1787                          representation for a device node can be used, where applicable.
1788
1789 **/
1790 static VOID
1791 DevPathToTextBluetoothLE (
1792   IN OUT POOL_PRINT  *Str,
1793   IN VOID            *DevPath,
1794   IN BOOLEAN         DisplayOnly,
1795   IN BOOLEAN         AllowShortcuts
1796   )
1797 {
1798   BLUETOOTH_LE_DEVICE_PATH  *BluetoothLE;
1799
1800   BluetoothLE = DevPath;
1801   UefiDevicePathLibCatPrint (
1802     Str,
1803     "BluetoothLE(%02x%02x%02x%02x%02x%02x,0x%02x)",
1804     BluetoothLE->Address.Address[0],
1805     BluetoothLE->Address.Address[1],
1806     BluetoothLE->Address.Address[2],
1807     BluetoothLE->Address.Address[3],
1808     BluetoothLE->Address.Address[4],
1809     BluetoothLE->Address.Address[5],
1810     BluetoothLE->Address.Type
1811     );
1812 }
1813
1814 /**
1815   Converts a DNS device path structure to its string representative.
1816
1817   @param Str             The string representative of input device.
1818   @param DevPath         The input device path structure.
1819   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1820                          of the display node is used, where applicable. If DisplayOnly
1821                          is FALSE, then the longer text representation of the display node
1822                          is used.
1823   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1824                          representation for a device node can be used, where applicable.
1825
1826 **/
1827 static VOID
1828 DevPathToTextDns (
1829   IN OUT POOL_PRINT  *Str,
1830   IN VOID            *DevPath,
1831   IN BOOLEAN         DisplayOnly,
1832   IN BOOLEAN         AllowShortcuts
1833   )
1834 {
1835   DNS_DEVICE_PATH  *DnsDevPath;
1836   UINT32           DnsServerIpCount;
1837   UINT32           DnsServerIpIndex;
1838
1839   DnsDevPath       = DevPath;
1840   DnsServerIpCount = (UINT32)(DevicePathNodeLength (DnsDevPath) - sizeof (EFI_DEVICE_PATH_PROTOCOL) - sizeof (DnsDevPath->IsIPv6)) / sizeof (EFI_IP_ADDRESS);
1841
1842   UefiDevicePathLibCatPrint (Str, "Dns(");
1843
1844   for (DnsServerIpIndex = 0; DnsServerIpIndex < DnsServerIpCount; DnsServerIpIndex++) {
1845     if (DnsDevPath->IsIPv6 == 0x00) {
1846       CatIPv4Address (Str, &(DnsDevPath->DnsServerIp[DnsServerIpIndex].v4));
1847     } else {
1848       CatIPv6Address (Str, &(DnsDevPath->DnsServerIp[DnsServerIpIndex].v6));
1849     }
1850
1851     if (DnsServerIpIndex < DnsServerIpCount - 1) {
1852       UefiDevicePathLibCatPrint (Str, ",");
1853     }
1854   }
1855
1856   UefiDevicePathLibCatPrint (Str, ")");
1857 }
1858
1859 /**
1860   Converts a URI device path structure to its string representative.
1861
1862   @param Str             The string representative of input device.
1863   @param DevPath         The input device path structure.
1864   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1865                          of the display node is used, where applicable. If DisplayOnly
1866                          is FALSE, then the longer text representation of the display node
1867                          is used.
1868   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1869                          representation for a device node can be used, where applicable.
1870
1871 **/
1872 static VOID
1873 DevPathToTextUri (
1874   IN OUT POOL_PRINT  *Str,
1875   IN VOID            *DevPath,
1876   IN BOOLEAN         DisplayOnly,
1877   IN BOOLEAN         AllowShortcuts
1878   )
1879 {
1880   URI_DEVICE_PATH  *Uri;
1881   UINTN            UriLength;
1882   CHAR8            *UriStr;
1883
1884   //
1885   // Uri in the device path may not be null terminated.
1886   //
1887   Uri       = DevPath;
1888   UriLength = DevicePathNodeLength (Uri) - sizeof (URI_DEVICE_PATH);
1889   UriStr    = AllocatePool (UriLength + 1);
1890   ASSERT (UriStr != NULL);
1891
1892   CopyMem (UriStr, Uri->Uri, UriLength);
1893   UriStr[UriLength] = '\0';
1894   UefiDevicePathLibCatPrint (Str, "Uri(%s)", UriStr);
1895   FreePool (UriStr);
1896 }
1897
1898 /**
1899   Converts a Hard drive device path structure to its string representative.
1900
1901   @param Str             The string representative of input device.
1902   @param DevPath         The input device path structure.
1903   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1904                          of the display node is used, where applicable. If DisplayOnly
1905                          is FALSE, then the longer text representation of the display node
1906                          is used.
1907   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1908                          representation for a device node can be used, where applicable.
1909
1910 **/
1911 static VOID
1912 DevPathToTextHardDrive (
1913   IN OUT POOL_PRINT  *Str,
1914   IN VOID            *DevPath,
1915   IN BOOLEAN         DisplayOnly,
1916   IN BOOLEAN         AllowShortcuts
1917   )
1918 {
1919   HARDDRIVE_DEVICE_PATH  *Hd;
1920
1921   Hd = DevPath;
1922   switch (Hd->SignatureType) {
1923     case SIGNATURE_TYPE_MBR:
1924       UefiDevicePathLibCatPrint (
1925         Str,
1926         "HD(%d,%s,0x%08x,",
1927         Hd->PartitionNumber,
1928         "MBR",
1929 //      *((UINT32 *)(&(Hd->Signature[0])))
1930         le32dec(&(Hd->Signature[0]))
1931         );
1932       break;
1933
1934     case SIGNATURE_TYPE_GUID:
1935       UefiDevicePathLibCatPrint (
1936         Str,
1937         "HD(%d,%s,%36s,",
1938         Hd->PartitionNumber,
1939         "GPT",
1940         G(&(Hd->Signature[0]))
1941         );
1942       break;
1943
1944     default:
1945       UefiDevicePathLibCatPrint (
1946         Str,
1947         "HD(%d,%d,0,",
1948         Hd->PartitionNumber,
1949         Hd->SignatureType
1950         );
1951       break;
1952   }
1953
1954   UefiDevicePathLibCatPrint (Str, "0x%lx,0x%lx)", Hd->PartitionStart, Hd->PartitionSize);
1955 }
1956
1957 /**
1958   Converts a CDROM device path structure to its string representative.
1959
1960   @param Str             The string representative of input device.
1961   @param DevPath         The input device path structure.
1962   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1963                          of the display node is used, where applicable. If DisplayOnly
1964                          is FALSE, then the longer text representation of the display node
1965                          is used.
1966   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1967                          representation for a device node can be used, where applicable.
1968
1969 **/
1970 static VOID
1971 DevPathToTextCDROM (
1972   IN OUT POOL_PRINT  *Str,
1973   IN VOID            *DevPath,
1974   IN BOOLEAN         DisplayOnly,
1975   IN BOOLEAN         AllowShortcuts
1976   )
1977 {
1978   CDROM_DEVICE_PATH  *Cd;
1979
1980   Cd = DevPath;
1981   if (DisplayOnly) {
1982     UefiDevicePathLibCatPrint (Str, "CDROM(0x%x)", Cd->BootEntry);
1983     return;
1984   }
1985
1986   UefiDevicePathLibCatPrint (Str, "CDROM(0x%x,0x%lx,0x%lx)", Cd->BootEntry, Cd->PartitionStart, Cd->PartitionSize);
1987 }
1988
1989 /**
1990   Converts a File device path structure to its string representative.
1991
1992   @param Str             The string representative of input device.
1993   @param DevPath         The input device path structure.
1994   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
1995                          of the display node is used, where applicable. If DisplayOnly
1996                          is FALSE, then the longer text representation of the display node
1997                          is used.
1998   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
1999                          representation for a device node can be used, where applicable.
2000
2001 **/
2002 static VOID
2003 DevPathToTextFilePath (
2004   IN OUT POOL_PRINT  *Str,
2005   IN VOID            *DevPath,
2006   IN BOOLEAN         DisplayOnly,
2007   IN BOOLEAN         AllowShortcuts
2008   )
2009 {
2010   FILEPATH_DEVICE_PATH  *Fp;
2011   char *name = NULL;
2012
2013   Fp = DevPath;
2014   ucs2_to_utf8(Fp->PathName, &name);
2015   UefiDevicePathLibCatPrint (Str, "File(%s)", name);
2016   free(name);
2017 }
2018
2019 /**
2020   Converts a Media protocol device path structure to its string representative.
2021
2022   @param Str             The string representative of input device.
2023   @param DevPath         The input device path structure.
2024   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
2025                          of the display node is used, where applicable. If DisplayOnly
2026                          is FALSE, then the longer text representation of the display node
2027                          is used.
2028   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
2029                          representation for a device node can be used, where applicable.
2030
2031 **/
2032 static VOID
2033 DevPathToTextMediaProtocol (
2034   IN OUT POOL_PRINT  *Str,
2035   IN VOID            *DevPath,
2036   IN BOOLEAN         DisplayOnly,
2037   IN BOOLEAN         AllowShortcuts
2038   )
2039 {
2040   MEDIA_PROTOCOL_DEVICE_PATH  *MediaProt;
2041
2042   MediaProt = DevPath;
2043   UefiDevicePathLibCatPrint (Str, "Media(%36s)", G(&MediaProt->Protocol));
2044 }
2045
2046 /**
2047   Converts a Firmware Volume device path structure to its string representative.
2048
2049   @param Str             The string representative of input device.
2050   @param DevPath         The input device path structure.
2051   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
2052                          of the display node is used, where applicable. If DisplayOnly
2053                          is FALSE, then the longer text representation of the display node
2054                          is used.
2055   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
2056                          representation for a device node can be used, where applicable.
2057
2058 **/
2059 static VOID
2060 DevPathToTextFv (
2061   IN OUT POOL_PRINT  *Str,
2062   IN VOID            *DevPath,
2063   IN BOOLEAN         DisplayOnly,
2064   IN BOOLEAN         AllowShortcuts
2065   )
2066 {
2067   MEDIA_FW_VOL_DEVICE_PATH  *Fv;
2068
2069   Fv = DevPath;
2070   UefiDevicePathLibCatPrint (Str, "Fv(%36s)", G(&Fv->FvName));
2071 }
2072
2073 /**
2074   Converts a Firmware Volume File device path structure to its string representative.
2075
2076   @param Str             The string representative of input device.
2077   @param DevPath         The input device path structure.
2078   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
2079                          of the display node is used, where applicable. If DisplayOnly
2080                          is FALSE, then the longer text representation of the display node
2081                          is used.
2082   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
2083                          representation for a device node can be used, where applicable.
2084
2085 **/
2086 static VOID
2087 DevPathToTextFvFile (
2088   IN OUT POOL_PRINT  *Str,
2089   IN VOID            *DevPath,
2090   IN BOOLEAN         DisplayOnly,
2091   IN BOOLEAN         AllowShortcuts
2092   )
2093 {
2094   MEDIA_FW_VOL_FILEPATH_DEVICE_PATH  *FvFile;
2095
2096   FvFile = DevPath;
2097   UefiDevicePathLibCatPrint (Str, "FvFile(%36s)", G(&FvFile->FvFileName));
2098 }
2099
2100 /**
2101   Converts a Relative Offset device path structure to its string representative.
2102
2103   @param Str             The string representative of input device.
2104   @param DevPath         The input device path structure.
2105   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
2106                          of the display node is used, where applicable. If DisplayOnly
2107                          is FALSE, then the longer text representation of the display node
2108                          is used.
2109   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
2110                          representation for a device node can be used, where applicable.
2111
2112 **/
2113 static VOID
2114 DevPathRelativeOffsetRange (
2115   IN OUT POOL_PRINT  *Str,
2116   IN VOID            *DevPath,
2117   IN BOOLEAN         DisplayOnly,
2118   IN BOOLEAN         AllowShortcuts
2119   )
2120 {
2121   MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH  *Offset;
2122
2123   Offset = DevPath;
2124   UefiDevicePathLibCatPrint (
2125     Str,
2126     "Offset(0x%lx,0x%lx)",
2127     Offset->StartingOffset,
2128     Offset->EndingOffset
2129     );
2130 }
2131
2132 /**
2133   Converts a Ram Disk device path structure to its string representative.
2134
2135   @param Str             The string representative of input device.
2136   @param DevPath         The input device path structure.
2137   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
2138                          of the display node is used, where applicable. If DisplayOnly
2139                          is FALSE, then the longer text representation of the display node
2140                          is used.
2141   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
2142                          representation for a device node can be used, where applicable.
2143
2144 **/
2145 static VOID
2146 DevPathToTextRamDisk (
2147   IN OUT POOL_PRINT  *Str,
2148   IN VOID            *DevPath,
2149   IN BOOLEAN         DisplayOnly,
2150   IN BOOLEAN         AllowShortcuts
2151   )
2152 {
2153   MEDIA_RAM_DISK_DEVICE_PATH  *RamDisk;
2154
2155   RamDisk = DevPath;
2156
2157   if (CompareGuid (&RamDisk->TypeGuid, &gEfiVirtualDiskGuid)) {
2158     UefiDevicePathLibCatPrint (
2159       Str,
2160       "VirtualDisk(0x%lx,0x%lx,%d)",
2161       LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0],
2162       LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0],
2163       RamDisk->Instance
2164       );
2165   } else if (CompareGuid (&RamDisk->TypeGuid, &gEfiVirtualCdGuid)) {
2166     UefiDevicePathLibCatPrint (
2167       Str,
2168       "VirtualCD(0x%lx,0x%lx,%d)",
2169       LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0],
2170       LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0],
2171       RamDisk->Instance
2172       );
2173   } else if (CompareGuid (&RamDisk->TypeGuid, &gEfiPersistentVirtualDiskGuid)) {
2174     UefiDevicePathLibCatPrint (
2175       Str,
2176       "PersistentVirtualDisk(0x%lx,0x%lx,%d)",
2177       LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0],
2178       LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0],
2179       RamDisk->Instance
2180       );
2181   } else if (CompareGuid (&RamDisk->TypeGuid, &gEfiPersistentVirtualCdGuid)) {
2182     UefiDevicePathLibCatPrint (
2183       Str,
2184       "PersistentVirtualCD(0x%lx,0x%lx,%d)",
2185       LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0],
2186       LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0],
2187       RamDisk->Instance
2188       );
2189   } else {
2190     UefiDevicePathLibCatPrint (
2191       Str,
2192       "RamDisk(0x%lx,0x%lx,%d,%36s)",
2193       LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0],
2194       LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0],
2195       RamDisk->Instance,
2196       G(&RamDisk->TypeGuid)
2197       );
2198   }
2199 }
2200
2201 /**
2202   Converts a BIOS Boot Specification device path structure to its string representative.
2203
2204   @param Str             The string representative of input device.
2205   @param DevPath         The input device path structure.
2206   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
2207                          of the display node is used, where applicable. If DisplayOnly
2208                          is FALSE, then the longer text representation of the display node
2209                          is used.
2210   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
2211                          representation for a device node can be used, where applicable.
2212
2213 **/
2214 static VOID
2215 DevPathToTextBBS (
2216   IN OUT POOL_PRINT  *Str,
2217   IN VOID            *DevPath,
2218   IN BOOLEAN         DisplayOnly,
2219   IN BOOLEAN         AllowShortcuts
2220   )
2221 {
2222   BBS_BBS_DEVICE_PATH  *Bbs;
2223   const char           *Type;
2224
2225   Bbs = DevPath;
2226   switch (Bbs->DeviceType) {
2227     case BBS_TYPE_FLOPPY:
2228       Type = "Floppy";
2229       break;
2230
2231     case BBS_TYPE_HARDDRIVE:
2232       Type = "HD";
2233       break;
2234
2235     case BBS_TYPE_CDROM:
2236       Type = "CDROM";
2237       break;
2238
2239     case BBS_TYPE_PCMCIA:
2240       Type = "PCMCIA";
2241       break;
2242
2243     case BBS_TYPE_USB:
2244       Type = "USB";
2245       break;
2246
2247     case BBS_TYPE_EMBEDDED_NETWORK:
2248       Type = "Network";
2249       break;
2250
2251     default:
2252       Type = NULL;
2253       break;
2254   }
2255
2256   if (Type != NULL) {
2257     UefiDevicePathLibCatPrint (Str, "BBS(%s,%s", Type, Bbs->String);
2258   } else {
2259     UefiDevicePathLibCatPrint (Str, "BBS(0x%x,%s", Bbs->DeviceType, Bbs->String);
2260   }
2261
2262   if (DisplayOnly) {
2263     UefiDevicePathLibCatPrint (Str, ")");
2264     return;
2265   }
2266
2267   UefiDevicePathLibCatPrint (Str, ",0x%x)", Bbs->StatusFlag);
2268 }
2269
2270 /**
2271   Converts an End-of-Device-Path structure to its string representative.
2272
2273   @param Str             The string representative of input device.
2274   @param DevPath         The input device path structure.
2275   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
2276                          of the display node is used, where applicable. If DisplayOnly
2277                          is FALSE, then the longer text representation of the display node
2278                          is used.
2279   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
2280                          representation for a device node can be used, where applicable.
2281
2282 **/
2283 static VOID
2284 DevPathToTextEndInstance (
2285   IN OUT POOL_PRINT  *Str,
2286   IN VOID            *DevPath,
2287   IN BOOLEAN         DisplayOnly,
2288   IN BOOLEAN         AllowShortcuts
2289   )
2290 {
2291   UefiDevicePathLibCatPrint (Str, ",");
2292 }
2293
2294 GLOBAL_REMOVE_IF_UNREFERENCED const DEVICE_PATH_TO_TEXT_GENERIC_TABLE  mUefiDevicePathLibToTextTableGeneric[] = {
2295   { HARDWARE_DEVICE_PATH,  "HardwarePath" },
2296   { ACPI_DEVICE_PATH,      "AcpiPath"     },
2297   { MESSAGING_DEVICE_PATH, "Msg"          },
2298   { MEDIA_DEVICE_PATH,     "MediaPath"    },
2299   { BBS_DEVICE_PATH,       "BbsPath"      },
2300   { 0,                     NULL            }
2301 };
2302
2303 /**
2304   Converts an unknown device path structure to its string representative.
2305
2306   @param Str             The string representative of input device.
2307   @param DevPath         The input device path structure.
2308   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
2309                          of the display node is used, where applicable. If DisplayOnly
2310                          is FALSE, then the longer text representation of the display node
2311                          is used.
2312   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
2313                          representation for a device node can be used, where applicable.
2314
2315 **/
2316 static VOID
2317 DevPathToTextNodeGeneric (
2318   IN OUT POOL_PRINT  *Str,
2319   IN VOID            *DevPath,
2320   IN BOOLEAN         DisplayOnly,
2321   IN BOOLEAN         AllowShortcuts
2322   )
2323 {
2324   EFI_DEVICE_PATH_PROTOCOL  *Node;
2325   UINTN                     Index;
2326
2327   Node = DevPath;
2328
2329   for (Index = 0; mUefiDevicePathLibToTextTableGeneric[Index].Text != NULL; Index++) {
2330     if (DevicePathType (Node) == mUefiDevicePathLibToTextTableGeneric[Index].Type) {
2331       break;
2332     }
2333   }
2334
2335   if (mUefiDevicePathLibToTextTableGeneric[Index].Text == NULL) {
2336     //
2337     // It's a node whose type cannot be recognized
2338     //
2339     UefiDevicePathLibCatPrint (Str, "Path(%d,%d", DevicePathType (Node), DevicePathSubType (Node));
2340   } else {
2341     //
2342     // It's a node whose type can be recognized
2343     //
2344     UefiDevicePathLibCatPrint (Str, "%s(%d", mUefiDevicePathLibToTextTableGeneric[Index].Text, DevicePathSubType (Node));
2345   }
2346
2347   Index = sizeof (EFI_DEVICE_PATH_PROTOCOL);
2348   if (Index < DevicePathNodeLength (Node)) {
2349     UefiDevicePathLibCatPrint (Str, ",");
2350     for ( ; Index < DevicePathNodeLength (Node); Index++) {
2351       UefiDevicePathLibCatPrint (Str, "%02x", ((UINT8 *)Node)[Index]);
2352     }
2353   }
2354
2355   UefiDevicePathLibCatPrint (Str, ")");
2356 }
2357
2358 static const DEVICE_PATH_TO_TEXT_TABLE  mUefiDevicePathLibToTextTable[] = {
2359   { HARDWARE_DEVICE_PATH,  HW_PCI_DP,                        DevPathToTextPci           },
2360   { HARDWARE_DEVICE_PATH,  HW_PCCARD_DP,                     DevPathToTextPccard        },
2361   { HARDWARE_DEVICE_PATH,  HW_MEMMAP_DP,                     DevPathToTextMemMap        },
2362   { HARDWARE_DEVICE_PATH,  HW_VENDOR_DP,                     DevPathToTextVendor        },
2363   { HARDWARE_DEVICE_PATH,  HW_CONTROLLER_DP,                 DevPathToTextController    },
2364   { HARDWARE_DEVICE_PATH,  HW_BMC_DP,                        DevPathToTextBmc           },
2365   { ACPI_DEVICE_PATH,      ACPI_DP,                          DevPathToTextAcpi          },
2366   { ACPI_DEVICE_PATH,      ACPI_EXTENDED_DP,                 DevPathToTextAcpiEx        },
2367   { ACPI_DEVICE_PATH,      ACPI_ADR_DP,                      DevPathToTextAcpiAdr       },
2368   { MESSAGING_DEVICE_PATH, MSG_ATAPI_DP,                     DevPathToTextAtapi         },
2369   { MESSAGING_DEVICE_PATH, MSG_SCSI_DP,                      DevPathToTextScsi          },
2370   { MESSAGING_DEVICE_PATH, MSG_FIBRECHANNEL_DP,              DevPathToTextFibre         },
2371   { MESSAGING_DEVICE_PATH, MSG_FIBRECHANNELEX_DP,            DevPathToTextFibreEx       },
2372   { MESSAGING_DEVICE_PATH, MSG_SASEX_DP,                     DevPathToTextSasEx         },
2373   { MESSAGING_DEVICE_PATH, MSG_NVME_NAMESPACE_DP,            DevPathToTextNVMe          },
2374   { MESSAGING_DEVICE_PATH, MSG_UFS_DP,                       DevPathToTextUfs           },
2375   { MESSAGING_DEVICE_PATH, MSG_SD_DP,                        DevPathToTextSd            },
2376   { MESSAGING_DEVICE_PATH, MSG_EMMC_DP,                      DevPathToTextEmmc          },
2377   { MESSAGING_DEVICE_PATH, MSG_1394_DP,                      DevPathToText1394          },
2378   { MESSAGING_DEVICE_PATH, MSG_USB_DP,                       DevPathToTextUsb           },
2379   { MESSAGING_DEVICE_PATH, MSG_USB_WWID_DP,                  DevPathToTextUsbWWID       },
2380   { MESSAGING_DEVICE_PATH, MSG_DEVICE_LOGICAL_UNIT_DP,       DevPathToTextLogicalUnit   },
2381   { MESSAGING_DEVICE_PATH, MSG_USB_CLASS_DP,                 DevPathToTextUsbClass      },
2382   { MESSAGING_DEVICE_PATH, MSG_SATA_DP,                      DevPathToTextSata          },
2383   { MESSAGING_DEVICE_PATH, MSG_I2O_DP,                       DevPathToTextI2O           },
2384   { MESSAGING_DEVICE_PATH, MSG_MAC_ADDR_DP,                  DevPathToTextMacAddr       },
2385   { MESSAGING_DEVICE_PATH, MSG_IPv4_DP,                      DevPathToTextIPv4          },
2386   { MESSAGING_DEVICE_PATH, MSG_IPv6_DP,                      DevPathToTextIPv6          },
2387   { MESSAGING_DEVICE_PATH, MSG_INFINIBAND_DP,                DevPathToTextInfiniBand    },
2388   { MESSAGING_DEVICE_PATH, MSG_UART_DP,                      DevPathToTextUart          },
2389   { MESSAGING_DEVICE_PATH, MSG_VENDOR_DP,                    DevPathToTextVendor        },
2390   { MESSAGING_DEVICE_PATH, MSG_ISCSI_DP,                     DevPathToTextiSCSI         },
2391   { MESSAGING_DEVICE_PATH, MSG_VLAN_DP,                      DevPathToTextVlan          },
2392   { MESSAGING_DEVICE_PATH, MSG_DNS_DP,                       DevPathToTextDns           },
2393   { MESSAGING_DEVICE_PATH, MSG_URI_DP,                       DevPathToTextUri           },
2394   { MESSAGING_DEVICE_PATH, MSG_BLUETOOTH_DP,                 DevPathToTextBluetooth     },
2395   { MESSAGING_DEVICE_PATH, MSG_WIFI_DP,                      DevPathToTextWiFi          },
2396   { MESSAGING_DEVICE_PATH, MSG_BLUETOOTH_LE_DP,              DevPathToTextBluetoothLE   },
2397   { MEDIA_DEVICE_PATH,     MEDIA_HARDDRIVE_DP,               DevPathToTextHardDrive     },
2398   { MEDIA_DEVICE_PATH,     MEDIA_CDROM_DP,                   DevPathToTextCDROM         },
2399   { MEDIA_DEVICE_PATH,     MEDIA_VENDOR_DP,                  DevPathToTextVendor        },
2400   { MEDIA_DEVICE_PATH,     MEDIA_PROTOCOL_DP,                DevPathToTextMediaProtocol },
2401   { MEDIA_DEVICE_PATH,     MEDIA_FILEPATH_DP,                DevPathToTextFilePath      },
2402   { MEDIA_DEVICE_PATH,     MEDIA_PIWG_FW_VOL_DP,             DevPathToTextFv            },
2403   { MEDIA_DEVICE_PATH,     MEDIA_PIWG_FW_FILE_DP,            DevPathToTextFvFile        },
2404   { MEDIA_DEVICE_PATH,     MEDIA_RELATIVE_OFFSET_RANGE_DP,   DevPathRelativeOffsetRange },
2405   { MEDIA_DEVICE_PATH,     MEDIA_RAM_DISK_DP,                DevPathToTextRamDisk       },
2406   { BBS_DEVICE_PATH,       BBS_BBS_DP,                       DevPathToTextBBS           },
2407   { END_DEVICE_PATH_TYPE,  END_INSTANCE_DEVICE_PATH_SUBTYPE, DevPathToTextEndInstance   },
2408   { 0,                     0,                                NULL                       }
2409 };
2410
2411 /**
2412   Converts a device node to its string representation.
2413
2414   @param DeviceNode        A Pointer to the device node to be converted.
2415   @param DisplayOnly       If DisplayOnly is TRUE, then the shorter text representation
2416                            of the display node is used, where applicable. If DisplayOnly
2417                            is FALSE, then the longer text representation of the display node
2418                            is used.
2419   @param AllowShortcuts    If AllowShortcuts is TRUE, then the shortcut forms of text
2420                            representation for a device node can be used, where applicable.
2421
2422   @return A pointer to the allocated text representation of the device node or NULL if DeviceNode
2423           is NULL or there was insufficient memory.
2424
2425 **/
2426 static char *
2427 EFIAPI
2428 UefiDevicePathLibConvertDeviceNodeToText (
2429   IN CONST EFI_DEVICE_PATH_PROTOCOL  *DeviceNode,
2430   IN BOOLEAN                         DisplayOnly,
2431   IN BOOLEAN                         AllowShortcuts
2432   )
2433 {
2434   POOL_PRINT           Str;
2435   UINTN                Index;
2436   DEVICE_PATH_TO_TEXT  ToText;
2437   EFI_DEVICE_PATH_PROTOCOL  *Node;
2438
2439   if (DeviceNode == NULL) {
2440     return NULL;
2441   }
2442
2443   ZeroMem (&Str, sizeof (Str));
2444
2445   //
2446   // Process the device path node
2447   // If not found, use a generic function
2448   //
2449   Node = __DECONST(EFI_DEVICE_PATH_PROTOCOL *, DeviceNode);
2450   ToText = DevPathToTextNodeGeneric;
2451   for (Index = 0; mUefiDevicePathLibToTextTable[Index].Function != NULL; Index++) {
2452     if ((DevicePathType (DeviceNode) == mUefiDevicePathLibToTextTable[Index].Type) &&
2453         (DevicePathSubType (DeviceNode) == mUefiDevicePathLibToTextTable[Index].SubType)
2454         )
2455     {
2456       ToText = mUefiDevicePathLibToTextTable[Index].Function;
2457       break;
2458     }
2459   }
2460
2461   //
2462   // Print this node
2463   //
2464   ToText (&Str, (VOID *)Node, DisplayOnly, AllowShortcuts);
2465
2466   ASSERT (Str.Str != NULL);
2467   return Str.Str;
2468 }
2469
2470 /**
2471   Converts a device path to its text representation.
2472
2473   @param DevicePath      A Pointer to the device to be converted.
2474   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
2475                          of the display node is used, where applicable. If DisplayOnly
2476                          is FALSE, then the longer text representation of the display node
2477                          is used.
2478   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
2479                          representation for a device node can be used, where applicable.
2480
2481   @return A pointer to the allocated text representation of the device path or
2482           NULL if DeviceNode is NULL or there was insufficient memory.
2483
2484 **/
2485 static char *
2486 EFIAPI
2487 UefiDevicePathLibConvertDevicePathToText (
2488   IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath,
2489   IN BOOLEAN                         DisplayOnly,
2490   IN BOOLEAN                         AllowShortcuts
2491   )
2492 {
2493   POOL_PRINT                Str;
2494   EFI_DEVICE_PATH_PROTOCOL  *Node;
2495   EFI_DEVICE_PATH_PROTOCOL  *AlignedNode;
2496   UINTN                     Index;
2497   DEVICE_PATH_TO_TEXT       ToText;
2498
2499   if (DevicePath == NULL) {
2500     return NULL;
2501   }
2502
2503   ZeroMem (&Str, sizeof (Str));
2504
2505   //
2506   // Process each device path node
2507   //
2508   Node = __DECONST(EFI_DEVICE_PATH_PROTOCOL *, DevicePath);
2509   while (!IsDevicePathEnd (Node)) {
2510     //
2511     // Find the handler to dump this device path node
2512     // If not found, use a generic function
2513     //
2514     ToText = DevPathToTextNodeGeneric;
2515     for (Index = 0; mUefiDevicePathLibToTextTable[Index].Function != NULL; Index += 1) {
2516       if ((DevicePathType (Node) == mUefiDevicePathLibToTextTable[Index].Type) &&
2517           (DevicePathSubType (Node) == mUefiDevicePathLibToTextTable[Index].SubType)
2518           )
2519       {
2520         ToText = mUefiDevicePathLibToTextTable[Index].Function;
2521         break;
2522       }
2523     }
2524
2525     //
2526     //  Put a path separator in if needed
2527     //
2528     if ((Str.Count != 0) && (ToText != DevPathToTextEndInstance)) {
2529       if (Str.Str[Str.Count] != ',') {
2530         UefiDevicePathLibCatPrint (&Str, "/");
2531       }
2532     }
2533
2534     AlignedNode = AllocateCopyPool (DevicePathNodeLength (Node), Node);
2535     //
2536     // Print this node of the device path
2537     //
2538     ToText (&Str, AlignedNode, DisplayOnly, AllowShortcuts);
2539     FreePool (AlignedNode);
2540
2541     //
2542     // Next device path node
2543     //
2544     Node = NextDevicePathNode (Node);
2545   }
2546
2547   if (Str.Str == NULL) {
2548     return AllocateZeroPool (sizeof (CHAR16));
2549   } else {
2550     return Str.Str;
2551   }
2552 }
2553
2554 ssize_t
2555 efidp_format_device_path(char *buf, size_t len, const_efidp dp, ssize_t max)
2556 {
2557         char *str;
2558         ssize_t retval;
2559
2560         /*
2561          * Basic sanity check on the device path.
2562          */
2563         if (!IsDevicePathValid((CONST EFI_DEVICE_PATH_PROTOCOL *) dp, max)) {
2564                 *buf = '\0';
2565                 return 0;
2566         }
2567
2568         str = UefiDevicePathLibConvertDevicePathToText (
2569                 __DECONST(EFI_DEVICE_PATH_PROTOCOL *, dp), FALSE, TRUE);
2570         if (str == NULL)
2571                 return -1;
2572         strlcpy(buf, str, len);
2573         retval = strlen(str);
2574         free(str);
2575
2576         return retval;
2577 }
2578
2579 ssize_t
2580 efidp_format_device_path_node(char *buf, size_t len, const_efidp dp)
2581 {
2582         char *str;
2583         ssize_t retval;
2584
2585         str = UefiDevicePathLibConvertDeviceNodeToText (
2586                 __DECONST(EFI_DEVICE_PATH_PROTOCOL *, dp), FALSE, TRUE);
2587         if (str == NULL)
2588                 return -1;
2589         strlcpy(buf, str, len);
2590         retval = strlen(str);
2591         free(str);
2592
2593         return retval;
2594 }
2595
2596 size_t
2597 efidp_size(const_efidp dp)
2598 {
2599
2600         return GetDevicePathSize(__DECONST(EFI_DEVICE_PATH_PROTOCOL *, dp));
2601 }
2602
2603 char *
2604 efidp_extract_file_path(const_efidp dp)
2605 {
2606         const FILEPATH_DEVICE_PATH  *fp;
2607         char *name = NULL;
2608
2609         fp = (const void *)dp;
2610         ucs2_to_utf8(fp->PathName, &name);
2611         return name;
2612 }