MdePkg/Library/UefiDevicePathLib/DevicePathToText.c

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