lib/libefivar/efivar-dp-format.c

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