xref: /freebsd/lib/libefivar/efivar-dp-parse.c (revision 259eac0149f0d2c01e1fcbeba3be1ba6fca6f8e1)

/*-
 * Copyright (c) 2017 Netflix, Inc.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

/*
 * Routines to format EFI_DEVICE_PATHs from the UEFI standard. Much of
 * this file is taken from EDK2 and rototilled.
 */

#include <ctype.h>
#include <efivar.h>
#include <stdio.h>
#include <string.h>
#include <wchar.h>

#include "efichar.h"

#include "efi-osdep.h"
#include "efivar-dp.h"

#include "uefi-dplib.h"

/* XXX STUBS -- this stuff doesn't work yet */
#define StrToIpv4Address(str, unk, ipv4ptr, unk2)	(void)(str)
#define StrToIpv6Address(str, unk, ipv6ptr, unk2)	(void)(str)

/*
 * OK. Now this is evil. Can't typedef it again. Sure beats changing them all.
 * Since we're doing it all as narrow characters since wchar_t can't be used on
 * FreeBSD and CHAR16 strings generally aren't a good fit. Since this parsing
 * doesn't need Unicode for anything, this works out well.
 */
#define CHAR16 char

/*
 * Taken from MdePkg/Library/UefiDevicePathLib/DevicePathFromText.c
 */

/** @file
  DevicePathFromText protocol as defined in the UEFI 2.0 specification.

Copyright (c) 2013 - 2018, Intel Corporation. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent

**/

// #include "UefiDevicePathLib.h"

/**

  Duplicates a string.

  @param  Src  Source string.

  @return The duplicated string.

**/
static
CHAR16 *
UefiDevicePathLibStrDuplicate (
  IN CONST CHAR16  *Src
  )
{
  return AllocateCopyPool (StrSize (Src), Src);
}

/**

  Get parameter in a pair of parentheses follow the given node name.
  For example, given the "Pci(0,1)" and NodeName "Pci", it returns "0,1".

  @param  Str      Device Path Text.
  @param  NodeName Name of the node.

  @return Parameter text for the node.

**/
static
CHAR16 *
GetParamByNodeName (
  IN CHAR16  *Str,
  IN const CHAR16  *NodeName
  )
{
  CHAR16  *ParamStr;
  CHAR16  *StrPointer;
  UINTN   NodeNameLength;
  UINTN   ParameterLength;

  //
  // Check whether the node name matchs
  //
  NodeNameLength = StrLen (NodeName);
  if (StrnCmp (Str, NodeName, NodeNameLength) != 0) {
    return NULL;
  }

  ParamStr = Str + NodeNameLength;
  if (!IS_LEFT_PARENTH (*ParamStr)) {
    return NULL;
  }

  //
  // Skip the found '(' and find first occurrence of ')'
  //
  ParamStr++;
  ParameterLength = 0;
  StrPointer      = ParamStr;
  while (!IS_NULL (*StrPointer)) {
    if (IS_RIGHT_PARENTH (*StrPointer)) {
      break;
    }

    StrPointer++;
    ParameterLength++;
  }

  if (IS_NULL (*StrPointer)) {
    //
    // ')' not found
    //
    return NULL;
  }

  ParamStr = AllocateCopyPool ((ParameterLength + 1) * sizeof (CHAR16), ParamStr);
  if (ParamStr == NULL) {
    return NULL;
  }

  //
  // Terminate the parameter string
  //
  ParamStr[ParameterLength] = '\0';

  return ParamStr;
}

/**
  Gets current sub-string from a string list, before return
  the list header is moved to next sub-string. The sub-string is separated
  by the specified character. For example, the separator is ',', the string
  list is "2,0,3", it returns "2", the remain list move to "0,3"

  @param  List        A string list separated by the specified separator
  @param  Separator   The separator character

  @return A pointer to the current sub-string

**/
static
CHAR16 *
SplitStr (
  IN OUT CHAR16  **List,
  IN     CHAR16  Separator
  )
{
  CHAR16  *Str;
  CHAR16  *ReturnStr;

  Str       = *List;
  ReturnStr = Str;

  if (IS_NULL (*Str)) {
    return ReturnStr;
  }

  //
  // Find first occurrence of the separator
  //
  while (!IS_NULL (*Str)) {
    if (*Str == Separator) {
      break;
    }

    Str++;
  }

  if (*Str == Separator) {
    //
    // Find a sub-string, terminate it
    //
    *Str = '\0';
    Str++;
  }

  //
  // Move to next sub-string
  //
  *List = Str;

  return ReturnStr;
}

/**
  Gets the next parameter string from the list.

  @param List            A string list separated by the specified separator

  @return A pointer to the current sub-string

**/
static
CHAR16 *
GetNextParamStr (
  IN OUT CHAR16  **List
  )
{
  //
  // The separator is comma
  //
  return SplitStr (List, ',');
}

/**
  Get one device node from entire device path text.

  @param DevicePath      On input, the current Device Path node; on output, the next device path node
  @param IsInstanceEnd   This node is the end of a device path instance

  @return A device node text or NULL if no more device node available

**/
static
CHAR16 *
GetNextDeviceNodeStr (
  IN OUT CHAR16   **DevicePath,
  OUT    BOOLEAN  *IsInstanceEnd
  )
{
  CHAR16  *Str;
  CHAR16  *ReturnStr;
  UINTN   ParenthesesStack;

  Str = *DevicePath;
  if (IS_NULL (*Str)) {
    return NULL;
  }

  //
  // Skip the leading '/', '(', ')' and ','
  //
  while (!IS_NULL (*Str)) {
    if (!IS_SLASH (*Str) &&
        !IS_COMMA (*Str) &&
        !IS_LEFT_PARENTH (*Str) &&
        !IS_RIGHT_PARENTH (*Str))
    {
      break;
    }

    Str++;
  }

  ReturnStr = Str;

  //
  // Scan for the separator of this device node, '/' or ','
  //
  ParenthesesStack = 0;
  while (!IS_NULL (*Str)) {
    if ((IS_COMMA (*Str) || IS_SLASH (*Str)) && (ParenthesesStack == 0)) {
      break;
    }

    if (IS_LEFT_PARENTH (*Str)) {
      ParenthesesStack++;
    } else if (IS_RIGHT_PARENTH (*Str)) {
      ParenthesesStack--;
    }

    Str++;
  }

  if (ParenthesesStack != 0) {
    //
    // The '(' doesn't pair with ')', invalid device path text
    //
    return NULL;
  }

  if (IS_COMMA (*Str)) {
    *IsInstanceEnd = TRUE;
    *Str           = '\0';
    Str++;
  } else {
    *IsInstanceEnd = FALSE;
    if (!IS_NULL (*Str)) {
      *Str = '\0';
      Str++;
    }
  }

  *DevicePath = Str;

  return ReturnStr;
}


#ifndef __FreeBSD__
/**
  Return whether the integer string is a hex string.

  @param Str             The integer string

  @retval TRUE   Hex string
  @retval FALSE  Decimal string

**/
static
BOOLEAN
IsHexStr (
  IN CHAR16  *Str
  )
{
  //
  // skip preceeding white space
  //
  while (*Str == ' ') {
    Str++;
  }

  //
  // skip preceeding zeros
  //
  while (*Str == '0') {
    Str++;
  }

  return (BOOLEAN)(*Str == 'x' || *Str == 'X');
}

/**

  Convert integer string to uint.

  @param Str             The integer string. If leading with "0x" or "0X", it's hexadecimal.

  @return A UINTN value represented by Str

**/
static
UINTN
Strtoi (
  IN CHAR16  *Str
  )
{
  if (IsHexStr (Str)) {
    return StrHexToUintn (Str);
  } else {
    return StrDecimalToUintn (Str);
  }
}

/**

  Convert integer string to 64 bit data.

  @param Str             The integer string. If leading with "0x" or "0X", it's hexadecimal.
  @param Data            A pointer to the UINT64 value represented by Str

**/
static
VOID
Strtoi64 (
  IN  CHAR16  *Str,
  OUT UINT64  *Data
  )
{
  if (IsHexStr (Str)) {
    *Data = StrHexToUint64 (Str);
  } else {
    *Data = StrDecimalToUint64 (Str);
  }
}
#endif

/**
  Converts a Unicode string to ASCII string.

  @param Str             The equivalent Unicode string
  @param AsciiStr        On input, it points to destination ASCII string buffer; on output, it points
                         to the next ASCII string next to it

**/
static
VOID
StrToAscii (
  IN     CHAR16  *Str,
  IN OUT CHAR8   **AsciiStr
  )
{
  CHAR8  *Dest;

  Dest = *AsciiStr;
  while (!IS_NULL (*Str)) {
    *(Dest++) = (CHAR8)*(Str++);
  }

  *Dest = 0;

  //
  // Return the string next to it
  //
  *AsciiStr = Dest + 1;
}

/**
  Converts a generic text device path node to device path structure.

  @param Type            The type of the device path node.
  @param TextDeviceNode  The input text device path node.

  @return A pointer to device path structure.
**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextGenericPath (
  IN UINT8   Type,
  IN CHAR16  *TextDeviceNode
  )
{
  EFI_DEVICE_PATH_PROTOCOL  *Node;
  CHAR16                    *SubtypeStr;
  CHAR16                    *DataStr;
  UINTN                     DataLength;

  SubtypeStr = GetNextParamStr (&TextDeviceNode);
  DataStr    = GetNextParamStr (&TextDeviceNode);

  if (DataStr == NULL) {
    DataLength = 0;
  } else {
    DataLength = StrLen (DataStr) / 2;
  }

  Node = CreateDeviceNode (
           Type,
           (UINT8)Strtoi (SubtypeStr),
           (UINT16)(sizeof (EFI_DEVICE_PATH_PROTOCOL) + DataLength)
           );

  if (Node != NULL) {
    StrHexToBytes (DataStr, DataLength * 2, (UINT8 *)(Node + 1), DataLength);
  }

  return Node;
}

/**
  Converts a generic text device path node to device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextPath (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16  *TypeStr;

  TypeStr = GetNextParamStr (&TextDeviceNode);

  return DevPathFromTextGenericPath ((UINT8)Strtoi (TypeStr), TextDeviceNode);
}

/**
  Converts a generic hardware text device path node to Hardware device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to Hardware device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextHardwarePath (
  IN CHAR16  *TextDeviceNode
  )
{
  return DevPathFromTextGenericPath (HARDWARE_DEVICE_PATH, TextDeviceNode);
}

/**
  Converts a text device path node to Hardware PCI device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to Hardware PCI device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextPci (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16           *FunctionStr;
  CHAR16           *DeviceStr;
  PCI_DEVICE_PATH  *Pci;

  DeviceStr   = GetNextParamStr (&TextDeviceNode);
  FunctionStr = GetNextParamStr (&TextDeviceNode);
  Pci         = (PCI_DEVICE_PATH *)CreateDeviceNode (
                                     HARDWARE_DEVICE_PATH,
                                     HW_PCI_DP,
                                     (UINT16)sizeof (PCI_DEVICE_PATH)
                                     );

  if (Pci != NULL) {
    Pci->Function = (UINT8)Strtoi (FunctionStr);
    Pci->Device   = (UINT8)Strtoi (DeviceStr);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)Pci;
}

/**
  Converts a text device path node to Hardware PC card device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to Hardware PC card device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextPcCard (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16              *FunctionNumberStr;
  PCCARD_DEVICE_PATH  *Pccard;

  FunctionNumberStr = GetNextParamStr (&TextDeviceNode);
  Pccard            = (PCCARD_DEVICE_PATH *)CreateDeviceNode (
                                              HARDWARE_DEVICE_PATH,
                                              HW_PCCARD_DP,
                                              (UINT16)sizeof (PCCARD_DEVICE_PATH)
                                              );

  if (Pccard != NULL) {
    Pccard->FunctionNumber = (UINT8)Strtoi (FunctionNumberStr);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)Pccard;
}

/**
  Converts a text device path node to Hardware memory map device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to Hardware memory map device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextMemoryMapped (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16              *MemoryTypeStr;
  CHAR16              *StartingAddressStr;
  CHAR16              *EndingAddressStr;
  MEMMAP_DEVICE_PATH  *MemMap;

  MemoryTypeStr      = GetNextParamStr (&TextDeviceNode);
  StartingAddressStr = GetNextParamStr (&TextDeviceNode);
  EndingAddressStr   = GetNextParamStr (&TextDeviceNode);
  MemMap             = (MEMMAP_DEVICE_PATH *)CreateDeviceNode (
                                               HARDWARE_DEVICE_PATH,
                                               HW_MEMMAP_DP,
                                               (UINT16)sizeof (MEMMAP_DEVICE_PATH)
                                               );

  if (MemMap != NULL) {
    MemMap->MemoryType = (UINT32)Strtoi (MemoryTypeStr);
    Strtoi64 (StartingAddressStr, &MemMap->StartingAddress);
    Strtoi64 (EndingAddressStr, &MemMap->EndingAddress);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)MemMap;
}

/**
  Converts a text device path node to Vendor device path structure based on the input Type
  and SubType.

  @param TextDeviceNode  The input Text device path node.
  @param Type            The type of device path node.
  @param SubType         The subtype of device path node.

  @return A pointer to the newly-created Vendor device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
ConvertFromTextVendor (
  IN CHAR16  *TextDeviceNode,
  IN UINT8   Type,
  IN UINT8   SubType
  )
{
  CHAR16              *GuidStr;
  CHAR16              *DataStr;
  UINTN               Length;
  VENDOR_DEVICE_PATH  *Vendor;

  GuidStr = GetNextParamStr (&TextDeviceNode);

  DataStr = GetNextParamStr (&TextDeviceNode);
  Length  = StrLen (DataStr);
  //
  // Two hex characters make up 1 buffer byte
  //
  Length = (Length + 1) / 2;

  Vendor = (VENDOR_DEVICE_PATH *)CreateDeviceNode (
                                   Type,
                                   SubType,
                                   (UINT16)(sizeof (VENDOR_DEVICE_PATH) + Length)
                                   );

  if (Vendor != NULL) {
    StrToGuid (GuidStr, &Vendor->Guid);
    StrHexToBytes (DataStr, Length * 2, (UINT8 *)(Vendor + 1), Length);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)Vendor;
}

/**
  Converts a text device path node to Vendor Hardware device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created Vendor Hardware device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextVenHw (
  IN CHAR16  *TextDeviceNode
  )
{
  return ConvertFromTextVendor (
           TextDeviceNode,
           HARDWARE_DEVICE_PATH,
           HW_VENDOR_DP
           );
}

/**
  Converts a text device path node to Hardware Controller device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created Hardware Controller device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextCtrl (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16                  *ControllerStr;
  CONTROLLER_DEVICE_PATH  *Controller;

  ControllerStr = GetNextParamStr (&TextDeviceNode);
  Controller    = (CONTROLLER_DEVICE_PATH *)CreateDeviceNode (
                                              HARDWARE_DEVICE_PATH,
                                              HW_CONTROLLER_DP,
                                              (UINT16)sizeof (CONTROLLER_DEVICE_PATH)
                                              );

  if (Controller != NULL) {
    Controller->ControllerNumber = (UINT32)Strtoi (ControllerStr);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)Controller;
}

/**
  Converts a text device path node to BMC device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created BMC device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextBmc (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16           *InterfaceTypeStr;
  CHAR16           *BaseAddressStr;
  BMC_DEVICE_PATH  *BmcDp;

  InterfaceTypeStr = GetNextParamStr (&TextDeviceNode);
  BaseAddressStr   = GetNextParamStr (&TextDeviceNode);
  BmcDp            = (BMC_DEVICE_PATH *)CreateDeviceNode (
                                          HARDWARE_DEVICE_PATH,
                                          HW_BMC_DP,
                                          (UINT16)sizeof (BMC_DEVICE_PATH)
                                          );

  if (BmcDp != NULL) {
    BmcDp->InterfaceType = (UINT8)Strtoi (InterfaceTypeStr);
    WriteUnaligned64 (
      (UINT64 *)(&BmcDp->BaseAddress),
      StrHexToUint64 (BaseAddressStr)
      );
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)BmcDp;
}

/**
  Converts a generic ACPI text device path node to ACPI device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to ACPI device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextAcpiPath (
  IN CHAR16  *TextDeviceNode
  )
{
  return DevPathFromTextGenericPath (ACPI_DEVICE_PATH, TextDeviceNode);
}

/**
  Converts a string to EisaId.

  @param Text   The input string.

  @return UINT32 EISA ID.
**/
static
UINT32
EisaIdFromText (
  IN CHAR16  *Text
  )
{
  return (((Text[0] - 'A' + 1) & 0x1f) << 10)
         + (((Text[1] - 'A' + 1) & 0x1f) <<  5)
         + (((Text[2] - 'A' + 1) & 0x1f) <<  0)
         + (UINT32)(StrHexToUintn (&Text[3]) << 16)
  ;
}

/**
  Converts a text device path node to ACPI HID device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created ACPI HID device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextAcpi (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16                *HIDStr;
  CHAR16                *UIDStr;
  ACPI_HID_DEVICE_PATH  *Acpi;

  HIDStr = GetNextParamStr (&TextDeviceNode);
  UIDStr = GetNextParamStr (&TextDeviceNode);
  Acpi   = (ACPI_HID_DEVICE_PATH *)CreateDeviceNode (
                                     ACPI_DEVICE_PATH,
                                     ACPI_DP,
                                     (UINT16)sizeof (ACPI_HID_DEVICE_PATH)
                                     );

  if (Acpi != NULL) {
    Acpi->HID = EisaIdFromText (HIDStr);
    Acpi->UID = (UINT32)Strtoi (UIDStr);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)Acpi;
}

/**
  Converts a text device path node to ACPI HID device path structure.

  @param TextDeviceNode  The input Text device path node.
  @param PnPId           The input plug and play identification.

  @return A pointer to the newly-created ACPI HID device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
ConvertFromTextAcpi (
  IN CHAR16  *TextDeviceNode,
  IN UINT32  PnPId
  )
{
  CHAR16                *UIDStr;
  ACPI_HID_DEVICE_PATH  *Acpi;

  UIDStr = GetNextParamStr (&TextDeviceNode);
  Acpi   = (ACPI_HID_DEVICE_PATH *)CreateDeviceNode (
                                     ACPI_DEVICE_PATH,
                                     ACPI_DP,
                                     (UINT16)sizeof (ACPI_HID_DEVICE_PATH)
                                     );

  if (Acpi != NULL) {
    Acpi->HID = EFI_PNP_ID (PnPId);
    Acpi->UID = (UINT32)Strtoi (UIDStr);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)Acpi;
}

/**
  Converts a text device path node to PCI root device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created PCI root device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextPciRoot (
  IN CHAR16  *TextDeviceNode
  )
{
  return ConvertFromTextAcpi (TextDeviceNode, 0x0a03);
}

/**
  Converts a text device path node to PCIE root device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created PCIE root device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextPcieRoot (
  IN CHAR16  *TextDeviceNode
  )
{
  return ConvertFromTextAcpi (TextDeviceNode, 0x0a08);
}

/**
  Converts a text device path node to Floppy device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created Floppy device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextFloppy (
  IN CHAR16  *TextDeviceNode
  )
{
  return ConvertFromTextAcpi (TextDeviceNode, 0x0604);
}

/**
  Converts a text device path node to Keyboard device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created  Keyboard device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextKeyboard (
  IN CHAR16  *TextDeviceNode
  )
{
  return ConvertFromTextAcpi (TextDeviceNode, 0x0301);
}

/**
  Converts a text device path node to Serial device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created Serial device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextSerial (
  IN CHAR16  *TextDeviceNode
  )
{
  return ConvertFromTextAcpi (TextDeviceNode, 0x0501);
}

/**
  Converts a text device path node to Parallel Port device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created Parallel Port device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextParallelPort (
  IN CHAR16  *TextDeviceNode
  )
{
  return ConvertFromTextAcpi (TextDeviceNode, 0x0401);
}

/**
  Converts a text device path node to ACPI extension device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created ACPI extension device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextAcpiEx (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16                         *HIDStr;
  CHAR16                         *CIDStr;
  CHAR16                         *UIDStr;
  CHAR16                         *HIDSTRStr;
  CHAR16                         *CIDSTRStr;
  CHAR16                         *UIDSTRStr;
  CHAR8                          *AsciiStr;
  UINT16                         Length;
  ACPI_EXTENDED_HID_DEVICE_PATH  *AcpiEx;

  HIDStr    = GetNextParamStr (&TextDeviceNode);
  CIDStr    = GetNextParamStr (&TextDeviceNode);
  UIDStr    = GetNextParamStr (&TextDeviceNode);
  HIDSTRStr = GetNextParamStr (&TextDeviceNode);
  CIDSTRStr = GetNextParamStr (&TextDeviceNode);
  UIDSTRStr = GetNextParamStr (&TextDeviceNode);

  Length = (UINT16)(sizeof (ACPI_EXTENDED_HID_DEVICE_PATH) + StrLen (HIDSTRStr) + 1);
  Length = (UINT16)(Length + StrLen (UIDSTRStr) + 1);
  Length = (UINT16)(Length + StrLen (CIDSTRStr) + 1);
  AcpiEx = (ACPI_EXTENDED_HID_DEVICE_PATH *)CreateDeviceNode (
                                              ACPI_DEVICE_PATH,
                                              ACPI_EXTENDED_DP,
                                              Length
                                              );

  if (AcpiEx != NULL) {
    AcpiEx->HID = EisaIdFromText (HIDStr);
    AcpiEx->CID = EisaIdFromText (CIDStr);
    AcpiEx->UID = (UINT32)Strtoi (UIDStr);

    AsciiStr = (CHAR8 *)((UINT8 *)AcpiEx + sizeof (ACPI_EXTENDED_HID_DEVICE_PATH));
    StrToAscii (HIDSTRStr, &AsciiStr);
    StrToAscii (UIDSTRStr, &AsciiStr);
    StrToAscii (CIDSTRStr, &AsciiStr);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)AcpiEx;
}

/**
  Converts a text device path node to ACPI extension device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created ACPI extension device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextAcpiExp (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16                         *HIDStr;
  CHAR16                         *CIDStr;
  CHAR16                         *UIDSTRStr;
  CHAR8                          *AsciiStr;
  UINT16                         Length;
  ACPI_EXTENDED_HID_DEVICE_PATH  *AcpiEx;

  HIDStr    = GetNextParamStr (&TextDeviceNode);
  CIDStr    = GetNextParamStr (&TextDeviceNode);
  UIDSTRStr = GetNextParamStr (&TextDeviceNode);
  Length    = (UINT16)(sizeof (ACPI_EXTENDED_HID_DEVICE_PATH) + StrLen (UIDSTRStr) + 3);
  AcpiEx    = (ACPI_EXTENDED_HID_DEVICE_PATH *)CreateDeviceNode (
                                                 ACPI_DEVICE_PATH,
                                                 ACPI_EXTENDED_DP,
                                                 Length
                                                 );

  if (AcpiEx == NULL) {
    return (EFI_DEVICE_PATH_PROTOCOL *)AcpiEx;
  }

  AcpiEx->HID = EisaIdFromText (HIDStr);
  //
  // According to UEFI spec, the CID parameter is optional and has a default value of 0.
  // So when the CID parameter is not specified or specified as 0 in the text device node.
  // Set the CID to 0 in the ACPI extension device path structure.
  //
  if ((*CIDStr == '\0') || (*CIDStr == '0')) {
    AcpiEx->CID = 0;
  } else {
    AcpiEx->CID = EisaIdFromText (CIDStr);
  }

  AcpiEx->UID = 0;

  AsciiStr = (CHAR8 *)((UINT8 *)AcpiEx + sizeof (ACPI_EXTENDED_HID_DEVICE_PATH));
  //
  // HID string is NULL
  //
  *AsciiStr = '\0';
  //
  // Convert UID string
  //
  AsciiStr++;
  StrToAscii (UIDSTRStr, &AsciiStr);
  //
  // CID string is NULL
  //
  *AsciiStr = '\0';

  return (EFI_DEVICE_PATH_PROTOCOL *)AcpiEx;
}

/**
  Converts a text device path node to ACPI _ADR device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created ACPI _ADR device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextAcpiAdr (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16                *DisplayDeviceStr;
  ACPI_ADR_DEVICE_PATH  *AcpiAdr;
  UINTN                 Index;
  UINTN                 Length;

  AcpiAdr = (ACPI_ADR_DEVICE_PATH *)CreateDeviceNode (
                                      ACPI_DEVICE_PATH,
                                      ACPI_ADR_DP,
                                      (UINT16)sizeof (ACPI_ADR_DEVICE_PATH)
                                      );
  if (AcpiAdr == NULL) {
    ASSERT (AcpiAdr != NULL);
    return (EFI_DEVICE_PATH_PROTOCOL *)AcpiAdr;
  }

  for (Index = 0; ; Index++) {
    DisplayDeviceStr = GetNextParamStr (&TextDeviceNode);
    if (IS_NULL (*DisplayDeviceStr)) {
      break;
    }

    if (Index > 0) {
      Length  = DevicePathNodeLength (AcpiAdr);
      AcpiAdr = ReallocatePool (
                  Length,
                  Length + sizeof (UINT32),
                  AcpiAdr
                  );

      if (AcpiAdr == NULL) {
        ASSERT (AcpiAdr != NULL);
        return (EFI_DEVICE_PATH_PROTOCOL *)AcpiAdr;
      }

      SetDevicePathNodeLength (AcpiAdr, Length + sizeof (UINT32));
    }

    (&AcpiAdr->ADR)[Index] = (UINT32)Strtoi (DisplayDeviceStr);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)AcpiAdr;
}

/**
  Converts a generic messaging text device path node to messaging device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to messaging device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextMsg (
  IN CHAR16  *TextDeviceNode
  )
{
  return DevPathFromTextGenericPath (MESSAGING_DEVICE_PATH, TextDeviceNode);
}

/**
  Converts a text device path node to Parallel Port device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created Parallel Port device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextAta (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16             *PrimarySecondaryStr;
  CHAR16             *SlaveMasterStr;
  CHAR16             *LunStr;
  ATAPI_DEVICE_PATH  *Atapi;

  Atapi = (ATAPI_DEVICE_PATH *)CreateDeviceNode (
                                 MESSAGING_DEVICE_PATH,
                                 MSG_ATAPI_DP,
                                 (UINT16)sizeof (ATAPI_DEVICE_PATH)
                                 );

  if (Atapi == NULL) {
    return (EFI_DEVICE_PATH_PROTOCOL *)Atapi;
  }

  PrimarySecondaryStr = GetNextParamStr (&TextDeviceNode);
  SlaveMasterStr      = GetNextParamStr (&TextDeviceNode);
  LunStr              = GetNextParamStr (&TextDeviceNode);

  if (StrCmp (PrimarySecondaryStr, "Primary") == 0) {
    Atapi->PrimarySecondary = 0;
  } else if (StrCmp (PrimarySecondaryStr, "Secondary") == 0) {
    Atapi->PrimarySecondary = 1;
  } else {
    Atapi->PrimarySecondary = (UINT8)Strtoi (PrimarySecondaryStr);
  }

  if (StrCmp (SlaveMasterStr, "Master") == 0) {
    Atapi->SlaveMaster = 0;
  } else if (StrCmp (SlaveMasterStr, "Slave") == 0) {
    Atapi->SlaveMaster = 1;
  } else {
    Atapi->SlaveMaster = (UINT8)Strtoi (SlaveMasterStr);
  }

  Atapi->Lun = (UINT16)Strtoi (LunStr);

  return (EFI_DEVICE_PATH_PROTOCOL *)Atapi;
}

/**
  Converts a text device path node to SCSI device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created SCSI device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextScsi (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16            *PunStr;
  CHAR16            *LunStr;
  SCSI_DEVICE_PATH  *Scsi;

  PunStr = GetNextParamStr (&TextDeviceNode);
  LunStr = GetNextParamStr (&TextDeviceNode);
  Scsi   = (SCSI_DEVICE_PATH *)CreateDeviceNode (
                                 MESSAGING_DEVICE_PATH,
                                 MSG_SCSI_DP,
                                 (UINT16)sizeof (SCSI_DEVICE_PATH)
                                 );

  if (Scsi != NULL) {
    Scsi->Pun = (UINT16)Strtoi (PunStr);
    Scsi->Lun = (UINT16)Strtoi (LunStr);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)Scsi;
}

/**
  Converts a text device path node to Fibre device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created Fibre device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextFibre (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16                    *WWNStr;
  CHAR16                    *LunStr;
  FIBRECHANNEL_DEVICE_PATH  *Fibre;

  WWNStr = GetNextParamStr (&TextDeviceNode);
  LunStr = GetNextParamStr (&TextDeviceNode);
  Fibre  = (FIBRECHANNEL_DEVICE_PATH *)CreateDeviceNode (
                                         MESSAGING_DEVICE_PATH,
                                         MSG_FIBRECHANNEL_DP,
                                         (UINT16)sizeof (FIBRECHANNEL_DEVICE_PATH)
                                         );

  if (Fibre != NULL) {
    Fibre->Reserved = 0;
    Strtoi64 (WWNStr, &Fibre->WWN);
    Strtoi64 (LunStr, &Fibre->Lun);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)Fibre;
}

/**
  Converts a text device path node to FibreEx device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created FibreEx device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextFibreEx (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16                      *WWNStr;
  CHAR16                      *LunStr;
  FIBRECHANNELEX_DEVICE_PATH  *FibreEx;

  WWNStr  = GetNextParamStr (&TextDeviceNode);
  LunStr  = GetNextParamStr (&TextDeviceNode);
  FibreEx = (FIBRECHANNELEX_DEVICE_PATH *)CreateDeviceNode (
                                            MESSAGING_DEVICE_PATH,
                                            MSG_FIBRECHANNELEX_DP,
                                            (UINT16)sizeof (FIBRECHANNELEX_DEVICE_PATH)
                                            );

  if (FibreEx != NULL) {
    FibreEx->Reserved = 0;
    Strtoi64 (WWNStr, (UINT64 *)(&FibreEx->WWN));
    Strtoi64 (LunStr, (UINT64 *)(&FibreEx->Lun));

    *(UINT64 *)(&FibreEx->WWN) = SwapBytes64 (*(UINT64 *)(&FibreEx->WWN));
    *(UINT64 *)(&FibreEx->Lun) = SwapBytes64 (*(UINT64 *)(&FibreEx->Lun));
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)FibreEx;
}

/**
  Converts a text device path node to 1394 device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created 1394 device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromText1394 (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16             *GuidStr;
  F1394_DEVICE_PATH  *F1394DevPath;

  GuidStr      = GetNextParamStr (&TextDeviceNode);
  F1394DevPath = (F1394_DEVICE_PATH *)CreateDeviceNode (
                                        MESSAGING_DEVICE_PATH,
                                        MSG_1394_DP,
                                        (UINT16)sizeof (F1394_DEVICE_PATH)
                                        );

  if (F1394DevPath != NULL) {
    F1394DevPath->Reserved = 0;
    F1394DevPath->Guid     = StrHexToUint64 (GuidStr);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)F1394DevPath;
}

/**
  Converts a text device path node to USB device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created USB device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsb (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16           *PortStr;
  CHAR16           *InterfaceStr;
  USB_DEVICE_PATH  *Usb;

  PortStr      = GetNextParamStr (&TextDeviceNode);
  InterfaceStr = GetNextParamStr (&TextDeviceNode);
  Usb          = (USB_DEVICE_PATH *)CreateDeviceNode (
                                      MESSAGING_DEVICE_PATH,
                                      MSG_USB_DP,
                                      (UINT16)sizeof (USB_DEVICE_PATH)
                                      );

  if (Usb != NULL) {
    Usb->ParentPortNumber = (UINT8)Strtoi (PortStr);
    Usb->InterfaceNumber  = (UINT8)Strtoi (InterfaceStr);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)Usb;
}

/**
  Converts a text device path node to I20 device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created I20 device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextI2O (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16           *TIDStr;
  I2O_DEVICE_PATH  *I2ODevPath;

  TIDStr     = GetNextParamStr (&TextDeviceNode);
  I2ODevPath = (I2O_DEVICE_PATH *)CreateDeviceNode (
                                    MESSAGING_DEVICE_PATH,
                                    MSG_I2O_DP,
                                    (UINT16)sizeof (I2O_DEVICE_PATH)
                                    );

  if (I2ODevPath != NULL) {
    I2ODevPath->Tid = (UINT32)Strtoi (TIDStr);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)I2ODevPath;
}

/**
  Converts a text device path node to Infini Band device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created Infini Band device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextInfiniband (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16                  *FlagsStr;
  CHAR16                  *GuidStr;
  CHAR16                  *SidStr;
  CHAR16                  *TidStr;
  CHAR16                  *DidStr;
  INFINIBAND_DEVICE_PATH  *InfiniBand;

  FlagsStr   = GetNextParamStr (&TextDeviceNode);
  GuidStr    = GetNextParamStr (&TextDeviceNode);
  SidStr     = GetNextParamStr (&TextDeviceNode);
  TidStr     = GetNextParamStr (&TextDeviceNode);
  DidStr     = GetNextParamStr (&TextDeviceNode);
  InfiniBand = (INFINIBAND_DEVICE_PATH *)CreateDeviceNode (
                                           MESSAGING_DEVICE_PATH,
                                           MSG_INFINIBAND_DP,
                                           (UINT16)sizeof (INFINIBAND_DEVICE_PATH)
                                           );

  if (InfiniBand != NULL) {
    InfiniBand->ResourceFlags = (UINT32)Strtoi (FlagsStr);
    StrToGuid (GuidStr, (EFI_GUID *)InfiniBand->PortGid);
    Strtoi64 (SidStr, &InfiniBand->ServiceId);
    Strtoi64 (TidStr, &InfiniBand->TargetPortId);
    Strtoi64 (DidStr, &InfiniBand->DeviceId);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)InfiniBand;
}

/**
  Converts a text device path node to Vendor-Defined Messaging device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created Vendor-Defined Messaging device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextVenMsg (
  IN CHAR16  *TextDeviceNode
  )
{
  return ConvertFromTextVendor (
           TextDeviceNode,
           MESSAGING_DEVICE_PATH,
           MSG_VENDOR_DP
           );
}

/**
  Converts a text device path node to Vendor defined PC-ANSI device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created Vendor defined PC-ANSI device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextVenPcAnsi (
  IN CHAR16  *TextDeviceNode
  )
{
  VENDOR_DEVICE_PATH  *Vendor;

  Vendor = (VENDOR_DEVICE_PATH *)CreateDeviceNode (
                                   MESSAGING_DEVICE_PATH,
                                   MSG_VENDOR_DP,
                                   (UINT16)sizeof (VENDOR_DEVICE_PATH)
                                   );

  if (Vendor != NULL) {
    CopyGuid (&Vendor->Guid, &gEfiPcAnsiGuid);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)Vendor;
}

/**
  Converts a text device path node to Vendor defined VT100 device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created Vendor defined VT100 device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextVenVt100 (
  IN CHAR16  *TextDeviceNode
  )
{
  VENDOR_DEVICE_PATH  *Vendor;

  Vendor = (VENDOR_DEVICE_PATH *)CreateDeviceNode (
                                   MESSAGING_DEVICE_PATH,
                                   MSG_VENDOR_DP,
                                   (UINT16)sizeof (VENDOR_DEVICE_PATH)
                                   );

  if (Vendor != NULL) {
    CopyGuid (&Vendor->Guid, &gEfiVT100Guid);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)Vendor;
}

/**
  Converts a text device path node to Vendor defined VT100 Plus device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created Vendor defined VT100 Plus device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextVenVt100Plus (
  IN CHAR16  *TextDeviceNode
  )
{
  VENDOR_DEVICE_PATH  *Vendor;

  Vendor = (VENDOR_DEVICE_PATH *)CreateDeviceNode (
                                   MESSAGING_DEVICE_PATH,
                                   MSG_VENDOR_DP,
                                   (UINT16)sizeof (VENDOR_DEVICE_PATH)
                                   );

  if (Vendor != NULL) {
    CopyGuid (&Vendor->Guid, &gEfiVT100PlusGuid);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)Vendor;
}

/**
  Converts a text device path node to Vendor defined UTF8 device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created Vendor defined UTF8 device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextVenUtf8 (
  IN CHAR16  *TextDeviceNode
  )
{
  VENDOR_DEVICE_PATH  *Vendor;

  Vendor = (VENDOR_DEVICE_PATH *)CreateDeviceNode (
                                   MESSAGING_DEVICE_PATH,
                                   MSG_VENDOR_DP,
                                   (UINT16)sizeof (VENDOR_DEVICE_PATH)
                                   );

  if (Vendor != NULL) {
    CopyGuid (&Vendor->Guid, &gEfiVTUTF8Guid);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)Vendor;
}

/**
  Converts a text device path node to UART Flow Control device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created UART Flow Control device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUartFlowCtrl (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16                         *ValueStr;
  UART_FLOW_CONTROL_DEVICE_PATH  *UartFlowControl;

  ValueStr        = GetNextParamStr (&TextDeviceNode);
  UartFlowControl = (UART_FLOW_CONTROL_DEVICE_PATH *)CreateDeviceNode (
                                                       MESSAGING_DEVICE_PATH,
                                                       MSG_VENDOR_DP,
                                                       (UINT16)sizeof (UART_FLOW_CONTROL_DEVICE_PATH)
                                                       );

  if (UartFlowControl != NULL) {
    CopyGuid (&UartFlowControl->Guid, &gEfiUartDevicePathGuid);
    if (StrCmp (ValueStr, "XonXoff") == 0) {
      UartFlowControl->FlowControlMap = 2;
    } else if (StrCmp (ValueStr, "Hardware") == 0) {
      UartFlowControl->FlowControlMap = 1;
    } else {
      UartFlowControl->FlowControlMap = 0;
    }
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)UartFlowControl;
}

/**
  Converts a text device path node to Serial Attached SCSI device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created Serial Attached SCSI device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextSAS (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16           *AddressStr;
  CHAR16           *LunStr;
  CHAR16           *RTPStr;
  CHAR16           *SASSATAStr;
  CHAR16           *LocationStr;
  CHAR16           *ConnectStr;
  CHAR16           *DriveBayStr;
  CHAR16           *ReservedStr;
  UINT16           Info;
  UINT16           Uint16;
  SAS_DEVICE_PATH  *Sas;

  AddressStr  = GetNextParamStr (&TextDeviceNode);
  LunStr      = GetNextParamStr (&TextDeviceNode);
  RTPStr      = GetNextParamStr (&TextDeviceNode);
  SASSATAStr  = GetNextParamStr (&TextDeviceNode);
  LocationStr = GetNextParamStr (&TextDeviceNode);
  ConnectStr  = GetNextParamStr (&TextDeviceNode);
  DriveBayStr = GetNextParamStr (&TextDeviceNode);
  ReservedStr = GetNextParamStr (&TextDeviceNode);
  Sas         = (SAS_DEVICE_PATH *)CreateDeviceNode (
                                     MESSAGING_DEVICE_PATH,
                                     MSG_VENDOR_DP,
                                     (UINT16)sizeof (SAS_DEVICE_PATH)
                                     );

  if (Sas == NULL) {
    return (EFI_DEVICE_PATH_PROTOCOL *)Sas;
  }

  CopyGuid (&Sas->Guid, &gEfiSasDevicePathGuid);
  Strtoi64 (AddressStr, &Sas->SasAddress);
  Strtoi64 (LunStr, &Sas->Lun);
  Sas->RelativeTargetPort = (UINT16)Strtoi (RTPStr);

  if (StrCmp (SASSATAStr, "NoTopology") == 0) {
    Info = 0x0;
  } else if ((StrCmp (SASSATAStr, "SATA") == 0) || (StrCmp (SASSATAStr, "SAS") == 0)) {
    Uint16 = (UINT16)Strtoi (DriveBayStr);
    if (Uint16 == 0) {
      Info = 0x1;
    } else {
      Info = (UINT16)(0x2 | ((Uint16 - 1) << 8));
    }

    if (StrCmp (SASSATAStr, "SATA") == 0) {
      Info |= BIT4;
    }

    //
    // Location is an integer between 0 and 1 or else
    // the keyword Internal (0) or External (1).
    //
    if (StrCmp (LocationStr, "External") == 0) {
      Uint16 = 1;
    } else if (StrCmp (LocationStr, "Internal") == 0) {
      Uint16 = 0;
    } else {
      Uint16 = ((UINT16)Strtoi (LocationStr) & BIT0);
    }

    Info |= (Uint16 << 5);

    //
    // Connect is an integer between 0 and 3 or else
    // the keyword Direct (0) or Expanded (1).
    //
    if (StrCmp (ConnectStr, "Expanded") == 0) {
      Uint16 = 1;
    } else if (StrCmp (ConnectStr, "Direct") == 0) {
      Uint16 = 0;
    } else {
      Uint16 = ((UINT16)Strtoi (ConnectStr) & (BIT0 | BIT1));
    }

    Info |= (Uint16 << 6);
  } else {
    Info = (UINT16)Strtoi (SASSATAStr);
  }

  Sas->DeviceTopology = Info;
  Sas->Reserved       = (UINT32)Strtoi (ReservedStr);

  return (EFI_DEVICE_PATH_PROTOCOL *)Sas;
}

/**
  Converts a text device path node to Serial Attached SCSI Ex device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created Serial Attached SCSI Ex device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextSasEx (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16             *AddressStr;
  CHAR16             *LunStr;
  CHAR16             *RTPStr;
  CHAR16             *SASSATAStr;
  CHAR16             *LocationStr;
  CHAR16             *ConnectStr;
  CHAR16             *DriveBayStr;
  UINT16             Info;
  UINT16             Uint16;
  UINT64             SasAddress;
  UINT64             Lun;
  SASEX_DEVICE_PATH  *SasEx;

  AddressStr  = GetNextParamStr (&TextDeviceNode);
  LunStr      = GetNextParamStr (&TextDeviceNode);
  RTPStr      = GetNextParamStr (&TextDeviceNode);
  SASSATAStr  = GetNextParamStr (&TextDeviceNode);
  LocationStr = GetNextParamStr (&TextDeviceNode);
  ConnectStr  = GetNextParamStr (&TextDeviceNode);
  DriveBayStr = GetNextParamStr (&TextDeviceNode);
  SasEx       = (SASEX_DEVICE_PATH *)CreateDeviceNode (
                                       MESSAGING_DEVICE_PATH,
                                       MSG_SASEX_DP,
                                       (UINT16)sizeof (SASEX_DEVICE_PATH)
                                       );

  if (SasEx == NULL) {
    return (EFI_DEVICE_PATH_PROTOCOL *)SasEx;
  }

  Strtoi64 (AddressStr, &SasAddress);
  Strtoi64 (LunStr, &Lun);
  WriteUnaligned64 ((UINT64 *)&SasEx->SasAddress, SwapBytes64 (SasAddress));
  WriteUnaligned64 ((UINT64 *)&SasEx->Lun, SwapBytes64 (Lun));
  SasEx->RelativeTargetPort = (UINT16)Strtoi (RTPStr);

  if (StrCmp (SASSATAStr, "NoTopology") == 0) {
    Info = 0x0;
  } else if ((StrCmp (SASSATAStr, "SATA") == 0) || (StrCmp (SASSATAStr, "SAS") == 0)) {
    Uint16 = (UINT16)Strtoi (DriveBayStr);
    if (Uint16 == 0) {
      Info = 0x1;
    } else {
      Info = (UINT16)(0x2 | ((Uint16 - 1) << 8));
    }

    if (StrCmp (SASSATAStr, "SATA") == 0) {
      Info |= BIT4;
    }

    //
    // Location is an integer between 0 and 1 or else
    // the keyword Internal (0) or External (1).
    //
    if (StrCmp (LocationStr, "External") == 0) {
      Uint16 = 1;
    } else if (StrCmp (LocationStr, "Internal") == 0) {
      Uint16 = 0;
    } else {
      Uint16 = ((UINT16)Strtoi (LocationStr) & BIT0);
    }

    Info |= (Uint16 << 5);

    //
    // Connect is an integer between 0 and 3 or else
    // the keyword Direct (0) or Expanded (1).
    //
    if (StrCmp (ConnectStr, "Expanded") == 0) {
      Uint16 = 1;
    } else if (StrCmp (ConnectStr, "Direct") == 0) {
      Uint16 = 0;
    } else {
      Uint16 = ((UINT16)Strtoi (ConnectStr) & (BIT0 | BIT1));
    }

    Info |= (Uint16 << 6);
  } else {
    Info = (UINT16)Strtoi (SASSATAStr);
  }

  SasEx->DeviceTopology = Info;

  return (EFI_DEVICE_PATH_PROTOCOL *)SasEx;
}

/**
  Converts a text device path node to NVM Express Namespace device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created NVM Express Namespace device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextNVMe (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16                      *NamespaceIdStr;
  CHAR16                      *NamespaceUuidStr;
  NVME_NAMESPACE_DEVICE_PATH  *Nvme;
  UINT8                       *Uuid;
  UINTN                       Index;

  NamespaceIdStr   = GetNextParamStr (&TextDeviceNode);
  NamespaceUuidStr = GetNextParamStr (&TextDeviceNode);
  Nvme             = (NVME_NAMESPACE_DEVICE_PATH *)CreateDeviceNode (
                                                     MESSAGING_DEVICE_PATH,
                                                     MSG_NVME_NAMESPACE_DP,
                                                     (UINT16)sizeof (NVME_NAMESPACE_DEVICE_PATH)
                                                     );

  if (Nvme != NULL) {
    Nvme->NamespaceId = (UINT32)Strtoi (NamespaceIdStr);
    Uuid              = (UINT8 *)&Nvme->NamespaceUuid;

    Index = sizeof (Nvme->NamespaceUuid) / sizeof (UINT8);
    while (Index-- != 0) {
      Uuid[Index] = (UINT8)StrHexToUintn (SplitStr (&NamespaceUuidStr, '-'));
    }
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)Nvme;
}

/**
  Converts a text device path node to UFS device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created UFS device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUfs (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16           *PunStr;
  CHAR16           *LunStr;
  UFS_DEVICE_PATH  *Ufs;

  PunStr = GetNextParamStr (&TextDeviceNode);
  LunStr = GetNextParamStr (&TextDeviceNode);
  Ufs    = (UFS_DEVICE_PATH *)CreateDeviceNode (
                                MESSAGING_DEVICE_PATH,
                                MSG_UFS_DP,
                                (UINT16)sizeof (UFS_DEVICE_PATH)
                                );

  if (Ufs != NULL) {
    Ufs->Pun = (UINT8)Strtoi (PunStr);
    Ufs->Lun = (UINT8)Strtoi (LunStr);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)Ufs;
}

/**
  Converts a text device path node to SD (Secure Digital) device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created SD device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextSd (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16          *SlotNumberStr;
  SD_DEVICE_PATH  *Sd;

  SlotNumberStr = GetNextParamStr (&TextDeviceNode);
  Sd            = (SD_DEVICE_PATH *)CreateDeviceNode (
                                      MESSAGING_DEVICE_PATH,
                                      MSG_SD_DP,
                                      (UINT16)sizeof (SD_DEVICE_PATH)
                                      );

  if (Sd != NULL) {
    Sd->SlotNumber = (UINT8)Strtoi (SlotNumberStr);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)Sd;
}

/**
  Converts a text device path node to EMMC (Embedded MMC) device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created EMMC device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextEmmc (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16            *SlotNumberStr;
  EMMC_DEVICE_PATH  *Emmc;

  SlotNumberStr = GetNextParamStr (&TextDeviceNode);
  Emmc          = (EMMC_DEVICE_PATH *)CreateDeviceNode (
                                        MESSAGING_DEVICE_PATH,
                                        MSG_EMMC_DP,
                                        (UINT16)sizeof (EMMC_DEVICE_PATH)
                                        );

  if (Emmc != NULL) {
    Emmc->SlotNumber = (UINT8)Strtoi (SlotNumberStr);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)Emmc;
}

/**
  Converts a text device path node to Debug Port device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created Debug Port device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextDebugPort (
  IN CHAR16  *TextDeviceNode
  )
{
  VENDOR_DEVICE_PATH  *Vend;

  Vend = (VENDOR_DEVICE_PATH *)CreateDeviceNode (
                                 MESSAGING_DEVICE_PATH,
                                 MSG_VENDOR_DP,
                                 (UINT16)sizeof (VENDOR_DEVICE_PATH)
                                 );

  if (Vend != NULL) {
    CopyGuid (&Vend->Guid, &gEfiDebugPortProtocolGuid);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)Vend;
}

/**
  Converts a text device path node to MAC device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created MAC device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextMAC (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16                *AddressStr;
  CHAR16                *IfTypeStr;
  UINTN                 Length;
  MAC_ADDR_DEVICE_PATH  *MACDevPath;

  AddressStr = GetNextParamStr (&TextDeviceNode);
  IfTypeStr  = GetNextParamStr (&TextDeviceNode);
  MACDevPath = (MAC_ADDR_DEVICE_PATH *)CreateDeviceNode (
                                         MESSAGING_DEVICE_PATH,
                                         MSG_MAC_ADDR_DP,
                                         (UINT16)sizeof (MAC_ADDR_DEVICE_PATH)
                                         );

  if (MACDevPath != NULL) {
    MACDevPath->IfType = (UINT8)Strtoi (IfTypeStr);

    Length = sizeof (EFI_MAC_ADDRESS);
    if ((MACDevPath->IfType == 0x01) || (MACDevPath->IfType == 0x00)) {
      Length = 6;
    }

    StrHexToBytes (AddressStr, Length * 2, MACDevPath->MacAddress.Addr, Length);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)MACDevPath;
}

/**
  Converts a text format to the network protocol ID.

  @param Text  String of protocol field.

  @return Network protocol ID .

**/
static
UINTN
NetworkProtocolFromText (
  IN CHAR16  *Text
  )
{
  if (StrCmp (Text, "UDP") == 0) {
    return RFC_1700_UDP_PROTOCOL;
  }

  if (StrCmp (Text, "TCP") == 0) {
    return RFC_1700_TCP_PROTOCOL;
  }

  return Strtoi (Text);
}

/**
  Converts a text device path node to IPV4 device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created IPV4 device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextIPv4 (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16            *RemoteIPStr;
  CHAR16            *ProtocolStr;
  CHAR16            *TypeStr;
  CHAR16            *LocalIPStr;
  CHAR16            *GatewayIPStr;
  CHAR16            *SubnetMaskStr;
  IPv4_DEVICE_PATH  *IPv4;

  RemoteIPStr   = GetNextParamStr (&TextDeviceNode);
  ProtocolStr   = GetNextParamStr (&TextDeviceNode);
  TypeStr       = GetNextParamStr (&TextDeviceNode);
  LocalIPStr    = GetNextParamStr (&TextDeviceNode);
  GatewayIPStr  = GetNextParamStr (&TextDeviceNode);
  SubnetMaskStr = GetNextParamStr (&TextDeviceNode);
  IPv4          = (IPv4_DEVICE_PATH *)CreateDeviceNode (
                                        MESSAGING_DEVICE_PATH,
                                        MSG_IPv4_DP,
                                        (UINT16)sizeof (IPv4_DEVICE_PATH)
                                        );

  if (IPv4 == NULL) {
    return (EFI_DEVICE_PATH_PROTOCOL *)IPv4;
  }

  StrToIpv4Address (RemoteIPStr, NULL, &IPv4->RemoteIpAddress, NULL);
  IPv4->Protocol = (UINT16)NetworkProtocolFromText (ProtocolStr);
  if (StrCmp (TypeStr, "Static") == 0) {
    IPv4->StaticIpAddress = TRUE;
  } else {
    IPv4->StaticIpAddress = FALSE;
  }

  StrToIpv4Address (LocalIPStr, NULL, &IPv4->LocalIpAddress, NULL);
  if (!IS_NULL (*GatewayIPStr) && !IS_NULL (*SubnetMaskStr)) {
    StrToIpv4Address (GatewayIPStr, NULL, &IPv4->GatewayIpAddress, NULL);
    StrToIpv4Address (SubnetMaskStr, NULL, &IPv4->SubnetMask, NULL);
  } else {
    ZeroMem (&IPv4->GatewayIpAddress, sizeof (IPv4->GatewayIpAddress));
    ZeroMem (&IPv4->SubnetMask, sizeof (IPv4->SubnetMask));
  }

  IPv4->LocalPort  = 0;
  IPv4->RemotePort = 0;

  return (EFI_DEVICE_PATH_PROTOCOL *)IPv4;
}

/**
  Converts a text device path node to IPV6 device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created IPV6 device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextIPv6 (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16            *RemoteIPStr;
  CHAR16            *ProtocolStr;
  CHAR16            *TypeStr;
  CHAR16            *LocalIPStr;
  CHAR16            *GatewayIPStr;
  CHAR16            *PrefixLengthStr;
  IPv6_DEVICE_PATH  *IPv6;

  RemoteIPStr     = GetNextParamStr (&TextDeviceNode);
  ProtocolStr     = GetNextParamStr (&TextDeviceNode);
  TypeStr         = GetNextParamStr (&TextDeviceNode);
  LocalIPStr      = GetNextParamStr (&TextDeviceNode);
  PrefixLengthStr = GetNextParamStr (&TextDeviceNode);
  GatewayIPStr    = GetNextParamStr (&TextDeviceNode);
  IPv6            = (IPv6_DEVICE_PATH *)CreateDeviceNode (
                                          MESSAGING_DEVICE_PATH,
                                          MSG_IPv6_DP,
                                          (UINT16)sizeof (IPv6_DEVICE_PATH)
                                          );

  if (IPv6 == NULL) {
    return (EFI_DEVICE_PATH_PROTOCOL *)IPv6;
  }

  StrToIpv6Address (RemoteIPStr, NULL, &IPv6->RemoteIpAddress, NULL);
  IPv6->Protocol = (UINT16)NetworkProtocolFromText (ProtocolStr);
  if (StrCmp (TypeStr, "Static") == 0) {
    IPv6->IpAddressOrigin = 0;
  } else if (StrCmp (TypeStr, "StatelessAutoConfigure") == 0) {
    IPv6->IpAddressOrigin = 1;
  } else {
    IPv6->IpAddressOrigin = 2;
  }

  StrToIpv6Address (LocalIPStr, NULL, &IPv6->LocalIpAddress, NULL);
  if (!IS_NULL (*GatewayIPStr) && !IS_NULL (*PrefixLengthStr)) {
    StrToIpv6Address (GatewayIPStr, NULL, &IPv6->GatewayIpAddress, NULL);
    IPv6->PrefixLength = (UINT8)Strtoi (PrefixLengthStr);
  } else {
    ZeroMem (&IPv6->GatewayIpAddress, sizeof (IPv6->GatewayIpAddress));
    IPv6->PrefixLength = 0;
  }

  IPv6->LocalPort  = 0;
  IPv6->RemotePort = 0;

  return (EFI_DEVICE_PATH_PROTOCOL *)IPv6;
}

/**
  Converts a text device path node to UART device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created UART device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUart (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16            *BaudStr;
  CHAR16            *DataBitsStr;
  CHAR16            *ParityStr;
  CHAR16            *StopBitsStr;
  UART_DEVICE_PATH  *Uart;

  BaudStr     = GetNextParamStr (&TextDeviceNode);
  DataBitsStr = GetNextParamStr (&TextDeviceNode);
  ParityStr   = GetNextParamStr (&TextDeviceNode);
  StopBitsStr = GetNextParamStr (&TextDeviceNode);
  Uart        = (UART_DEVICE_PATH *)CreateDeviceNode (
                                      MESSAGING_DEVICE_PATH,
                                      MSG_UART_DP,
                                      (UINT16)sizeof (UART_DEVICE_PATH)
                                      );

  if (Uart == NULL) {
    return (EFI_DEVICE_PATH_PROTOCOL *)Uart;
  }

  if (StrCmp (BaudStr, "DEFAULT") == 0) {
    Uart->BaudRate = 115200;
  } else {
    Strtoi64 (BaudStr, &Uart->BaudRate);
  }

  Uart->DataBits = (UINT8)((StrCmp (DataBitsStr, "DEFAULT") == 0) ? 8 : Strtoi (DataBitsStr));
  switch (*ParityStr) {
    case 'D':
      Uart->Parity = 0;
      break;

    case 'N':
      Uart->Parity = 1;
      break;

    case 'E':
      Uart->Parity = 2;
      break;

    case 'O':
      Uart->Parity = 3;
      break;

    case 'M':
      Uart->Parity = 4;
      break;

    case 'S':
      Uart->Parity = 5;
      break;

    default:
      Uart->Parity = (UINT8)Strtoi (ParityStr);
      break;
  }

  if (StrCmp (StopBitsStr, "D") == 0) {
    Uart->StopBits = (UINT8)0;
  } else if (StrCmp (StopBitsStr, "1") == 0) {
    Uart->StopBits = (UINT8)1;
  } else if (StrCmp (StopBitsStr, "1.5") == 0) {
    Uart->StopBits = (UINT8)2;
  } else if (StrCmp (StopBitsStr, "2") == 0) {
    Uart->StopBits = (UINT8)3;
  } else {
    Uart->StopBits = (UINT8)Strtoi (StopBitsStr);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)Uart;
}

/**
  Converts a text device path node to USB class device path structure.

  @param TextDeviceNode  The input Text device path node.
  @param UsbClassText    A pointer to USB_CLASS_TEXT structure to be integrated to USB Class Text.

  @return A pointer to the newly-created USB class device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
ConvertFromTextUsbClass (
  IN CHAR16          *TextDeviceNode,
  IN USB_CLASS_TEXT  *UsbClassText
  )
{
  CHAR16                 *VIDStr;
  CHAR16                 *PIDStr;
  CHAR16                 *ClassStr;
  CHAR16                 *SubClassStr;
  CHAR16                 *ProtocolStr;
  USB_CLASS_DEVICE_PATH  *UsbClass;

  UsbClass = (USB_CLASS_DEVICE_PATH *)CreateDeviceNode (
                                        MESSAGING_DEVICE_PATH,
                                        MSG_USB_CLASS_DP,
                                        (UINT16)sizeof (USB_CLASS_DEVICE_PATH)
                                        );

  if (UsbClass == NULL) {
    return (EFI_DEVICE_PATH_PROTOCOL *)UsbClass;
  }

  VIDStr = GetNextParamStr (&TextDeviceNode);
  PIDStr = GetNextParamStr (&TextDeviceNode);
  if (UsbClassText->ClassExist) {
    ClassStr = GetNextParamStr (&TextDeviceNode);
    if (*ClassStr == '\0') {
      UsbClass->DeviceClass = 0xFF;
    } else {
      UsbClass->DeviceClass = (UINT8)Strtoi (ClassStr);
    }
  } else {
    UsbClass->DeviceClass = UsbClassText->Class;
  }

  if (UsbClassText->SubClassExist) {
    SubClassStr = GetNextParamStr (&TextDeviceNode);
    if (*SubClassStr == '\0') {
      UsbClass->DeviceSubClass = 0xFF;
    } else {
      UsbClass->DeviceSubClass = (UINT8)Strtoi (SubClassStr);
    }
  } else {
    UsbClass->DeviceSubClass = UsbClassText->SubClass;
  }

  ProtocolStr = GetNextParamStr (&TextDeviceNode);

  if (*VIDStr == '\0') {
    UsbClass->VendorId = 0xFFFF;
  } else {
    UsbClass->VendorId = (UINT16)Strtoi (VIDStr);
  }

  if (*PIDStr == '\0') {
    UsbClass->ProductId = 0xFFFF;
  } else {
    UsbClass->ProductId = (UINT16)Strtoi (PIDStr);
  }

  if (*ProtocolStr == '\0') {
    UsbClass->DeviceProtocol = 0xFF;
  } else {
    UsbClass->DeviceProtocol = (UINT8)Strtoi (ProtocolStr);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)UsbClass;
}

/**
  Converts a text device path node to USB class device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created USB class device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbClass (
  IN CHAR16  *TextDeviceNode
  )
{
  USB_CLASS_TEXT  UsbClassText;

  UsbClassText.ClassExist    = TRUE;
  UsbClassText.SubClassExist = TRUE;

  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
}

/**
  Converts a text device path node to USB audio device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created USB audio device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbAudio (
  IN CHAR16  *TextDeviceNode
  )
{
  USB_CLASS_TEXT  UsbClassText;

  UsbClassText.ClassExist    = FALSE;
  UsbClassText.Class         = USB_CLASS_AUDIO;
  UsbClassText.SubClassExist = TRUE;

  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
}

/**
  Converts a text device path node to USB CDC Control device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created USB CDC Control device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbCDCControl (
  IN CHAR16  *TextDeviceNode
  )
{
  USB_CLASS_TEXT  UsbClassText;

  UsbClassText.ClassExist    = FALSE;
  UsbClassText.Class         = USB_CLASS_CDCCONTROL;
  UsbClassText.SubClassExist = TRUE;

  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
}

/**
  Converts a text device path node to USB HID device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created USB HID device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbHID (
  IN CHAR16  *TextDeviceNode
  )
{
  USB_CLASS_TEXT  UsbClassText;

  UsbClassText.ClassExist    = FALSE;
  UsbClassText.Class         = USB_CLASS_HID;
  UsbClassText.SubClassExist = TRUE;

  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
}

/**
  Converts a text device path node to USB Image device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created USB Image device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbImage (
  IN CHAR16  *TextDeviceNode
  )
{
  USB_CLASS_TEXT  UsbClassText;

  UsbClassText.ClassExist    = FALSE;
  UsbClassText.Class         = USB_CLASS_IMAGE;
  UsbClassText.SubClassExist = TRUE;

  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
}

/**
  Converts a text device path node to USB Print device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created USB Print device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbPrinter (
  IN CHAR16  *TextDeviceNode
  )
{
  USB_CLASS_TEXT  UsbClassText;

  UsbClassText.ClassExist    = FALSE;
  UsbClassText.Class         = USB_CLASS_PRINTER;
  UsbClassText.SubClassExist = TRUE;

  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
}

/**
  Converts a text device path node to USB mass storage device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created USB mass storage device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbMassStorage (
  IN CHAR16  *TextDeviceNode
  )
{
  USB_CLASS_TEXT  UsbClassText;

  UsbClassText.ClassExist    = FALSE;
  UsbClassText.Class         = USB_CLASS_MASS_STORAGE;
  UsbClassText.SubClassExist = TRUE;

  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
}

/**
  Converts a text device path node to USB HUB device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created USB HUB device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbHub (
  IN CHAR16  *TextDeviceNode
  )
{
  USB_CLASS_TEXT  UsbClassText;

  UsbClassText.ClassExist    = FALSE;
  UsbClassText.Class         = USB_CLASS_HUB;
  UsbClassText.SubClassExist = TRUE;

  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
}

/**
  Converts a text device path node to USB CDC data device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created USB CDC data device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbCDCData (
  IN CHAR16  *TextDeviceNode
  )
{
  USB_CLASS_TEXT  UsbClassText;

  UsbClassText.ClassExist    = FALSE;
  UsbClassText.Class         = USB_CLASS_CDCDATA;
  UsbClassText.SubClassExist = TRUE;

  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
}

/**
  Converts a text device path node to USB smart card device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created USB smart card device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbSmartCard (
  IN CHAR16  *TextDeviceNode
  )
{
  USB_CLASS_TEXT  UsbClassText;

  UsbClassText.ClassExist    = FALSE;
  UsbClassText.Class         = USB_CLASS_SMART_CARD;
  UsbClassText.SubClassExist = TRUE;

  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
}

/**
  Converts a text device path node to USB video device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created USB video device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbVideo (
  IN CHAR16  *TextDeviceNode
  )
{
  USB_CLASS_TEXT  UsbClassText;

  UsbClassText.ClassExist    = FALSE;
  UsbClassText.Class         = USB_CLASS_VIDEO;
  UsbClassText.SubClassExist = TRUE;

  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
}

/**
  Converts a text device path node to USB diagnostic device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created USB diagnostic device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbDiagnostic (
  IN CHAR16  *TextDeviceNode
  )
{
  USB_CLASS_TEXT  UsbClassText;

  UsbClassText.ClassExist    = FALSE;
  UsbClassText.Class         = USB_CLASS_DIAGNOSTIC;
  UsbClassText.SubClassExist = TRUE;

  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
}

/**
  Converts a text device path node to USB wireless device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created USB wireless device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbWireless (
  IN CHAR16  *TextDeviceNode
  )
{
  USB_CLASS_TEXT  UsbClassText;

  UsbClassText.ClassExist    = FALSE;
  UsbClassText.Class         = USB_CLASS_WIRELESS;
  UsbClassText.SubClassExist = TRUE;

  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
}

/**
  Converts a text device path node to USB device firmware update device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created USB device firmware update device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbDeviceFirmwareUpdate (
  IN CHAR16  *TextDeviceNode
  )
{
  USB_CLASS_TEXT  UsbClassText;

  UsbClassText.ClassExist    = FALSE;
  UsbClassText.Class         = USB_CLASS_RESERVE;
  UsbClassText.SubClassExist = FALSE;
  UsbClassText.SubClass      = USB_SUBCLASS_FW_UPDATE;

  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
}

/**
  Converts a text device path node to USB IRDA bridge device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created USB IRDA bridge device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbIrdaBridge (
  IN CHAR16  *TextDeviceNode
  )
{
  USB_CLASS_TEXT  UsbClassText;

  UsbClassText.ClassExist    = FALSE;
  UsbClassText.Class         = USB_CLASS_RESERVE;
  UsbClassText.SubClassExist = FALSE;
  UsbClassText.SubClass      = USB_SUBCLASS_IRDA_BRIDGE;

  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
}

/**
  Converts a text device path node to USB text and measurement device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created USB text and measurement device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbTestAndMeasurement (
  IN CHAR16  *TextDeviceNode
  )
{
  USB_CLASS_TEXT  UsbClassText;

  UsbClassText.ClassExist    = FALSE;
  UsbClassText.Class         = USB_CLASS_RESERVE;
  UsbClassText.SubClassExist = FALSE;
  UsbClassText.SubClass      = USB_SUBCLASS_TEST;

  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
}

/**
  Converts a text device path node to USB WWID device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created USB WWID device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbWwid (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16                *VIDStr;
  CHAR16                *PIDStr;
  CHAR16                *InterfaceNumStr;
  CHAR16                *SerialNumberStr;
  USB_WWID_DEVICE_PATH  *UsbWwid;
  UINTN                 SerialNumberStrLen;

  VIDStr             = GetNextParamStr (&TextDeviceNode);
  PIDStr             = GetNextParamStr (&TextDeviceNode);
  InterfaceNumStr    = GetNextParamStr (&TextDeviceNode);
  SerialNumberStr    = GetNextParamStr (&TextDeviceNode);
  SerialNumberStrLen = StrLen (SerialNumberStr);
  if ((SerialNumberStrLen >= 2) &&
      (SerialNumberStr[0] == '\"') &&
      (SerialNumberStr[SerialNumberStrLen - 1] == '\"')
      )
  {
    SerialNumberStr[SerialNumberStrLen - 1] = '\0';
    SerialNumberStr++;
    SerialNumberStrLen -= 2;
  }

  UsbWwid = (USB_WWID_DEVICE_PATH *)CreateDeviceNode (
                                      MESSAGING_DEVICE_PATH,
                                      MSG_USB_WWID_DP,
                                      (UINT16)(sizeof (USB_WWID_DEVICE_PATH) + SerialNumberStrLen * sizeof (CHAR16))
                                      );

  if (UsbWwid != NULL) {
    UsbWwid->VendorId        = (UINT16)Strtoi (VIDStr);
    UsbWwid->ProductId       = (UINT16)Strtoi (PIDStr);
    UsbWwid->InterfaceNumber = (UINT16)Strtoi (InterfaceNumStr);

    //
    // There is no memory allocated in UsbWwid for the '\0' in SerialNumberStr.
    // Therefore, the '\0' will not be copied.
    //
    CopyMem (
      (UINT8 *)UsbWwid + sizeof (USB_WWID_DEVICE_PATH),
      SerialNumberStr,
      SerialNumberStrLen * sizeof (CHAR16)
      );
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)UsbWwid;
}

/**
  Converts a text device path node to Logic Unit device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created Logic Unit device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUnit (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16                           *LunStr;
  DEVICE_LOGICAL_UNIT_DEVICE_PATH  *LogicalUnit;

  LunStr      = GetNextParamStr (&TextDeviceNode);
  LogicalUnit = (DEVICE_LOGICAL_UNIT_DEVICE_PATH *)CreateDeviceNode (
                                                     MESSAGING_DEVICE_PATH,
                                                     MSG_DEVICE_LOGICAL_UNIT_DP,
                                                     (UINT16)sizeof (DEVICE_LOGICAL_UNIT_DEVICE_PATH)
                                                     );

  if (LogicalUnit != NULL) {
    LogicalUnit->Lun = (UINT8)Strtoi (LunStr);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)LogicalUnit;
}

/**
  Converts a text device path node to iSCSI device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created iSCSI device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextiSCSI (
  IN CHAR16  *TextDeviceNode
  )
{
  UINT16                       Options;
  CHAR16                       *NameStr;
  CHAR16                       *PortalGroupStr;
  CHAR16                       *LunStr;
  CHAR16                       *HeaderDigestStr;
  CHAR16                       *DataDigestStr;
  CHAR16                       *AuthenticationStr;
  CHAR16                       *ProtocolStr;
  CHAR8                        *AsciiStr;
  ISCSI_DEVICE_PATH_WITH_NAME  *ISCSIDevPath;
  UINT64                       Lun;

  NameStr           = GetNextParamStr (&TextDeviceNode);
  PortalGroupStr    = GetNextParamStr (&TextDeviceNode);
  LunStr            = GetNextParamStr (&TextDeviceNode);
  HeaderDigestStr   = GetNextParamStr (&TextDeviceNode);
  DataDigestStr     = GetNextParamStr (&TextDeviceNode);
  AuthenticationStr = GetNextParamStr (&TextDeviceNode);
  ProtocolStr       = GetNextParamStr (&TextDeviceNode);
  ISCSIDevPath      = (ISCSI_DEVICE_PATH_WITH_NAME *)CreateDeviceNode (
                                                       MESSAGING_DEVICE_PATH,
                                                       MSG_ISCSI_DP,
                                                       (UINT16)(sizeof (ISCSI_DEVICE_PATH_WITH_NAME) + StrLen (NameStr))
                                                       );

  if (ISCSIDevPath == NULL) {
    return (EFI_DEVICE_PATH_PROTOCOL *)ISCSIDevPath;
  }

  AsciiStr = ISCSIDevPath->TargetName;
  StrToAscii (NameStr, &AsciiStr);

  ISCSIDevPath->TargetPortalGroupTag = (UINT16)Strtoi (PortalGroupStr);
  Strtoi64 (LunStr, &Lun);
  WriteUnaligned64 ((UINT64 *)&ISCSIDevPath->Lun, SwapBytes64 (Lun));

  Options = 0x0000;
  if (StrCmp (HeaderDigestStr, "CRC32C") == 0) {
    Options |= 0x0002;
  }

  if (StrCmp (DataDigestStr, "CRC32C") == 0) {
    Options |= 0x0008;
  }

  if (StrCmp (AuthenticationStr, "None") == 0) {
    Options |= 0x0800;
  }

  if (StrCmp (AuthenticationStr, "CHAP_UNI") == 0) {
    Options |= 0x1000;
  }

  ISCSIDevPath->LoginOption = (UINT16)Options;

  if (IS_NULL (*ProtocolStr) || (StrCmp (ProtocolStr, "TCP") == 0)) {
    ISCSIDevPath->NetworkProtocol = 0;
  } else {
    //
    // Undefined and reserved.
    //
    ISCSIDevPath->NetworkProtocol = 1;
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)ISCSIDevPath;
}

/**
  Converts a text device path node to VLAN device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created VLAN device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextVlan (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16            *VlanStr;
  VLAN_DEVICE_PATH  *Vlan;

  VlanStr = GetNextParamStr (&TextDeviceNode);
  Vlan    = (VLAN_DEVICE_PATH *)CreateDeviceNode (
                                  MESSAGING_DEVICE_PATH,
                                  MSG_VLAN_DP,
                                  (UINT16)sizeof (VLAN_DEVICE_PATH)
                                  );

  if (Vlan != NULL) {
    Vlan->VlanId = (UINT16)Strtoi (VlanStr);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)Vlan;
}

/**
  Converts a text device path node to Bluetooth device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created Bluetooth device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextBluetooth (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16                 *BluetoothStr;
  BLUETOOTH_DEVICE_PATH  *BluetoothDp;

  BluetoothStr = GetNextParamStr (&TextDeviceNode);
  BluetoothDp  = (BLUETOOTH_DEVICE_PATH *)CreateDeviceNode (
                                            MESSAGING_DEVICE_PATH,
                                            MSG_BLUETOOTH_DP,
                                            (UINT16)sizeof (BLUETOOTH_DEVICE_PATH)
                                            );

  if (BluetoothDp != NULL) {
    StrHexToBytes (
      BluetoothStr,
      sizeof (BLUETOOTH_ADDRESS) * 2,
      BluetoothDp->BD_ADDR.Address,
      sizeof (BLUETOOTH_ADDRESS)
      );
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)BluetoothDp;
}

/**
  Converts a text device path node to Wi-Fi device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created Wi-Fi device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextWiFi (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16            *SSIdStr;
  CHAR8             AsciiStr[33];
  UINTN             DataLen;
  WIFI_DEVICE_PATH  *WiFiDp;

  SSIdStr = GetNextParamStr (&TextDeviceNode);
  WiFiDp  = (WIFI_DEVICE_PATH *)CreateDeviceNode (
                                  MESSAGING_DEVICE_PATH,
                                  MSG_WIFI_DP,
                                  (UINT16)sizeof (WIFI_DEVICE_PATH)
                                  );

  if ((NULL != SSIdStr) && (NULL != WiFiDp)) {
    DataLen = StrLen (SSIdStr);
    if (StrLen (SSIdStr) > 32) {
      SSIdStr[32] = '\0';
      DataLen     = 32;
    }

    UnicodeStrToAsciiStrS (SSIdStr, AsciiStr, sizeof (AsciiStr));
    CopyMem (WiFiDp->SSId, AsciiStr, DataLen);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)WiFiDp;
}

/**
  Converts a text device path node to Bluetooth LE device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created Bluetooth LE device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextBluetoothLE (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16                    *BluetoothLeAddrStr;
  CHAR16                    *BluetoothLeAddrTypeStr;
  BLUETOOTH_LE_DEVICE_PATH  *BluetoothLeDp;

  BluetoothLeAddrStr     = GetNextParamStr (&TextDeviceNode);
  BluetoothLeAddrTypeStr = GetNextParamStr (&TextDeviceNode);
  BluetoothLeDp          = (BLUETOOTH_LE_DEVICE_PATH *)CreateDeviceNode (
                                                         MESSAGING_DEVICE_PATH,
                                                         MSG_BLUETOOTH_LE_DP,
                                                         (UINT16)sizeof (BLUETOOTH_LE_DEVICE_PATH)
                                                         );

  if (BluetoothLeDp != NULL) {
    BluetoothLeDp->Address.Type = (UINT8)Strtoi (BluetoothLeAddrTypeStr);
    StrHexToBytes (
      BluetoothLeAddrStr,
      sizeof (BluetoothLeDp->Address.Address) * 2,
      BluetoothLeDp->Address.Address,
      sizeof (BluetoothLeDp->Address.Address)
      );
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)BluetoothLeDp;
}

/**
  Converts a text device path node to DNS device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created DNS device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextDns (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16           *DeviceNodeStr;
  CHAR16           *DeviceNodeStrPtr;
  UINT32           DnsServerIpCount;
  UINT16           DnsDeviceNodeLength;
  DNS_DEVICE_PATH  *DnsDeviceNode;
  UINT32           DnsServerIpIndex;
  CHAR16           *DnsServerIp;

  //
  // Count the DNS server address number.
  //
  DeviceNodeStr = UefiDevicePathLibStrDuplicate (TextDeviceNode);
  if (DeviceNodeStr == NULL) {
    return NULL;
  }

  DeviceNodeStrPtr = DeviceNodeStr;

  DnsServerIpCount = 0;
  while (DeviceNodeStrPtr != NULL && *DeviceNodeStrPtr != '\0') {
    GetNextParamStr (&DeviceNodeStrPtr);
    DnsServerIpCount++;
  }

  FreePool (DeviceNodeStr);
  DeviceNodeStr = NULL;

  //
  // One or more instances of the DNS server address in EFI_IP_ADDRESS,
  // otherwise, NULL will be returned.
  //
  if (DnsServerIpCount == 0) {
    return NULL;
  }

  //
  // Create the DNS DeviceNode.
  //
  DnsDeviceNodeLength = (UINT16)(sizeof (EFI_DEVICE_PATH_PROTOCOL) + sizeof (UINT8) + DnsServerIpCount * sizeof (EFI_IP_ADDRESS));
  DnsDeviceNode       = (DNS_DEVICE_PATH *)CreateDeviceNode (
                                             MESSAGING_DEVICE_PATH,
                                             MSG_DNS_DP,
                                             DnsDeviceNodeLength
                                             );
  if (DnsDeviceNode == NULL) {
    return NULL;
  }

  //
  // Confirm the DNS server address is IPv4 or IPv6 type.
  //
  DeviceNodeStrPtr = TextDeviceNode;
  while (!IS_NULL (*DeviceNodeStrPtr)) {
    if (*DeviceNodeStrPtr == '.') {
      DnsDeviceNode->IsIPv6 = 0x00;
      break;
    }

    if (*DeviceNodeStrPtr == ':') {
      DnsDeviceNode->IsIPv6 = 0x01;
      break;
    }

    DeviceNodeStrPtr++;
  }

  for (DnsServerIpIndex = 0; DnsServerIpIndex < DnsServerIpCount; DnsServerIpIndex++) {
    DnsServerIp = GetNextParamStr (&TextDeviceNode);
    if (DnsDeviceNode->IsIPv6 == 0x00) {
      StrToIpv4Address (DnsServerIp, NULL, &(DnsDeviceNode->DnsServerIp[DnsServerIpIndex].v4), NULL);
    } else {
      StrToIpv6Address (DnsServerIp, NULL, &(DnsDeviceNode->DnsServerIp[DnsServerIpIndex].v6), NULL);
    }
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)DnsDeviceNode;
}

/**
  Converts a text device path node to URI device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created URI device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUri (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16           *UriStr;
  UINTN            UriLength;
  URI_DEVICE_PATH  *Uri;

  UriStr    = GetNextParamStr (&TextDeviceNode);
  UriLength = StrnLenS (UriStr, MAX_UINT16 - sizeof (URI_DEVICE_PATH));
  Uri       = (URI_DEVICE_PATH *)CreateDeviceNode (
                                   MESSAGING_DEVICE_PATH,
                                   MSG_URI_DP,
                                   (UINT16)(sizeof (URI_DEVICE_PATH) + UriLength)
                                   );

  while (Uri != NULL && UriLength-- != 0) {
    Uri->Uri[UriLength] = (CHAR8)UriStr[UriLength];
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)Uri;
}

/**
  Converts a media text device path node to media device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to media device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextMediaPath (
  IN CHAR16  *TextDeviceNode
  )
{
  return DevPathFromTextGenericPath (MEDIA_DEVICE_PATH, TextDeviceNode);
}

/**
  Converts a text device path node to HD device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created HD device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextHD (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16                 *PartitionStr;
  CHAR16                 *TypeStr;
  CHAR16                 *SignatureStr;
  CHAR16                 *StartStr;
  CHAR16                 *SizeStr;
  UINT32                 Signature32;
  HARDDRIVE_DEVICE_PATH  *Hd;

  PartitionStr = GetNextParamStr (&TextDeviceNode);
  TypeStr      = GetNextParamStr (&TextDeviceNode);
  SignatureStr = GetNextParamStr (&TextDeviceNode);
  StartStr     = GetNextParamStr (&TextDeviceNode);
  SizeStr      = GetNextParamStr (&TextDeviceNode);
  Hd           = (HARDDRIVE_DEVICE_PATH *)CreateDeviceNode (
                                            MEDIA_DEVICE_PATH,
                                            MEDIA_HARDDRIVE_DP,
                                            (UINT16)sizeof (HARDDRIVE_DEVICE_PATH)
                                            );

  if (Hd == NULL) {
    return (EFI_DEVICE_PATH_PROTOCOL *)Hd;
  }

  Hd->PartitionNumber = (UINT32)Strtoi (PartitionStr);

  ZeroMem (Hd->Signature, 16);
  Hd->MBRType = (UINT8)0;

  if (StrCmp (TypeStr, "MBR") == 0) {
    Hd->SignatureType = SIGNATURE_TYPE_MBR;
    Hd->MBRType       = 0x01;

    Signature32 = (UINT32)Strtoi (SignatureStr);
    CopyMem (Hd->Signature, &Signature32, sizeof (UINT32));
  } else if (StrCmp (TypeStr, "GPT") == 0) {
    Hd->SignatureType = SIGNATURE_TYPE_GUID;
    Hd->MBRType       = 0x02;

    StrToGuid (SignatureStr, (EFI_GUID *)Hd->Signature);
  } else {
    Hd->SignatureType = (UINT8)Strtoi (TypeStr);
  }

  Strtoi64 (StartStr, &Hd->PartitionStart);
  Strtoi64 (SizeStr, &Hd->PartitionSize);

  return (EFI_DEVICE_PATH_PROTOCOL *)Hd;
}

/**
  Converts a text device path node to CDROM device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created CDROM device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextCDROM (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16             *EntryStr;
  CHAR16             *StartStr;
  CHAR16             *SizeStr;
  CDROM_DEVICE_PATH  *CDROMDevPath;

  EntryStr     = GetNextParamStr (&TextDeviceNode);
  StartStr     = GetNextParamStr (&TextDeviceNode);
  SizeStr      = GetNextParamStr (&TextDeviceNode);
  CDROMDevPath = (CDROM_DEVICE_PATH *)CreateDeviceNode (
                                        MEDIA_DEVICE_PATH,
                                        MEDIA_CDROM_DP,
                                        (UINT16)sizeof (CDROM_DEVICE_PATH)
                                        );

  if (CDROMDevPath != NULL) {
    CDROMDevPath->BootEntry = (UINT32)Strtoi (EntryStr);
    Strtoi64 (StartStr, &CDROMDevPath->PartitionStart);
    Strtoi64 (SizeStr, &CDROMDevPath->PartitionSize);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)CDROMDevPath;
}

/**
  Converts a text device path node to Vendor-defined media device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created Vendor-defined media device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextVenMedia (
  IN CHAR16  *TextDeviceNode
  )
{
  return ConvertFromTextVendor (
           TextDeviceNode,
           MEDIA_DEVICE_PATH,
           MEDIA_VENDOR_DP
           );
}

/**
  Converts a text device path node to File device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created File device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextFilePath (
  IN CHAR16  *TextDeviceNode
  )
{
  FILEPATH_DEVICE_PATH  *File;

#ifndef __FreeBSD__
  File = (FILEPATH_DEVICE_PATH *)CreateDeviceNode (
                                   MEDIA_DEVICE_PATH,
                                   MEDIA_FILEPATH_DP,
                                   (UINT16)(sizeof (FILEPATH_DEVICE_PATH) + StrLen (TextDeviceNode) * 2)
                                   );

  if (File != NULL) {
    StrCpyS (File->PathName, StrLen (TextDeviceNode) + 1, TextDeviceNode);
  }
#else
  size_t len = (sizeof (FILEPATH_DEVICE_PATH) + StrLen (TextDeviceNode) * 2);
  efi_char *v;
  File = (FILEPATH_DEVICE_PATH *)CreateDeviceNode (
                                   MEDIA_DEVICE_PATH,
                                   MEDIA_FILEPATH_DP,
                                   (UINT16)len
                                   );
  if (File != NULL) {
    v = File->PathName;
    utf8_to_ucs2(TextDeviceNode, &v, &len);
  }
#endif

  return (EFI_DEVICE_PATH_PROTOCOL *)File;
}

/**
  Converts a text device path node to Media protocol device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created Media protocol device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextMedia (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16                      *GuidStr;
  MEDIA_PROTOCOL_DEVICE_PATH  *Media;

  GuidStr = GetNextParamStr (&TextDeviceNode);
  Media   = (MEDIA_PROTOCOL_DEVICE_PATH *)CreateDeviceNode (
                                            MEDIA_DEVICE_PATH,
                                            MEDIA_PROTOCOL_DP,
                                            (UINT16)sizeof (MEDIA_PROTOCOL_DEVICE_PATH)
                                            );

  if (Media != NULL) {
    StrToGuid (GuidStr, &Media->Protocol);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)Media;
}

/**
  Converts a text device path node to firmware volume device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created firmware volume device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextFv (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16                    *GuidStr;
  MEDIA_FW_VOL_DEVICE_PATH  *Fv;

  GuidStr = GetNextParamStr (&TextDeviceNode);
  Fv      = (MEDIA_FW_VOL_DEVICE_PATH *)CreateDeviceNode (
                                          MEDIA_DEVICE_PATH,
                                          MEDIA_PIWG_FW_VOL_DP,
                                          (UINT16)sizeof (MEDIA_FW_VOL_DEVICE_PATH)
                                          );

  if (Fv != NULL) {
    StrToGuid (GuidStr, &Fv->FvName);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)Fv;
}

/**
  Converts a text device path node to firmware file device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created firmware file device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextFvFile (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16                             *GuidStr;
  MEDIA_FW_VOL_FILEPATH_DEVICE_PATH  *FvFile;

  GuidStr = GetNextParamStr (&TextDeviceNode);
  FvFile  = (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *)CreateDeviceNode (
                                                   MEDIA_DEVICE_PATH,
                                                   MEDIA_PIWG_FW_FILE_DP,
                                                   (UINT16)sizeof (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH)
                                                   );

  if (FvFile != NULL) {
    StrToGuid (GuidStr, &FvFile->FvFileName);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)FvFile;
}

/**
  Converts a text device path node to text relative offset device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created Text device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextRelativeOffsetRange (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16                                   *StartingOffsetStr;
  CHAR16                                   *EndingOffsetStr;
  MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH  *Offset;

  StartingOffsetStr = GetNextParamStr (&TextDeviceNode);
  EndingOffsetStr   = GetNextParamStr (&TextDeviceNode);
  Offset            = (MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH *)CreateDeviceNode (
                                                                   MEDIA_DEVICE_PATH,
                                                                   MEDIA_RELATIVE_OFFSET_RANGE_DP,
                                                                   (UINT16)sizeof (MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH)
                                                                   );

  if (Offset != NULL) {
    Strtoi64 (StartingOffsetStr, &Offset->StartingOffset);
    Strtoi64 (EndingOffsetStr, &Offset->EndingOffset);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)Offset;
}

/**
  Converts a text device path node to text ram disk device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created Text device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextRamDisk (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16                      *StartingAddrStr;
  CHAR16                      *EndingAddrStr;
  CHAR16                      *TypeGuidStr;
  CHAR16                      *InstanceStr;
  MEDIA_RAM_DISK_DEVICE_PATH  *RamDisk;
  UINT64                      StartingAddr;
  UINT64                      EndingAddr;

  StartingAddrStr = GetNextParamStr (&TextDeviceNode);
  EndingAddrStr   = GetNextParamStr (&TextDeviceNode);
  InstanceStr     = GetNextParamStr (&TextDeviceNode);
  TypeGuidStr     = GetNextParamStr (&TextDeviceNode);
  RamDisk         = (MEDIA_RAM_DISK_DEVICE_PATH *)CreateDeviceNode (
                                                    MEDIA_DEVICE_PATH,
                                                    MEDIA_RAM_DISK_DP,
                                                    (UINT16)sizeof (MEDIA_RAM_DISK_DEVICE_PATH)
                                                    );

  if (RamDisk != NULL) {
    Strtoi64 (StartingAddrStr, &StartingAddr);
    WriteUnaligned64 ((UINT64 *)&(RamDisk->StartingAddr[0]), StartingAddr);
    Strtoi64 (EndingAddrStr, &EndingAddr);
    WriteUnaligned64 ((UINT64 *)&(RamDisk->EndingAddr[0]), EndingAddr);
    RamDisk->Instance = (UINT16)Strtoi (InstanceStr);
    StrToGuid (TypeGuidStr, &RamDisk->TypeGuid);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)RamDisk;
}

/**
  Converts a text device path node to text virtual disk device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created Text device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextVirtualDisk (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16                      *StartingAddrStr;
  CHAR16                      *EndingAddrStr;
  CHAR16                      *InstanceStr;
  MEDIA_RAM_DISK_DEVICE_PATH  *RamDisk;
  UINT64                      StartingAddr;
  UINT64                      EndingAddr;

  StartingAddrStr = GetNextParamStr (&TextDeviceNode);
  EndingAddrStr   = GetNextParamStr (&TextDeviceNode);
  InstanceStr     = GetNextParamStr (&TextDeviceNode);

  RamDisk = (MEDIA_RAM_DISK_DEVICE_PATH *)CreateDeviceNode (
                                            MEDIA_DEVICE_PATH,
                                            MEDIA_RAM_DISK_DP,
                                            (UINT16)sizeof (MEDIA_RAM_DISK_DEVICE_PATH)
                                            );

  if (RamDisk != NULL) {
    Strtoi64 (StartingAddrStr, &StartingAddr);
    WriteUnaligned64 ((UINT64 *)&(RamDisk->StartingAddr[0]), StartingAddr);
    Strtoi64 (EndingAddrStr, &EndingAddr);
    WriteUnaligned64 ((UINT64 *)&(RamDisk->EndingAddr[0]), EndingAddr);
    RamDisk->Instance = (UINT16)Strtoi (InstanceStr);
    CopyGuid (&RamDisk->TypeGuid, &gEfiVirtualDiskGuid);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)RamDisk;
}

/**
  Converts a text device path node to text virtual cd device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created Text device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextVirtualCd (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16                      *StartingAddrStr;
  CHAR16                      *EndingAddrStr;
  CHAR16                      *InstanceStr;
  MEDIA_RAM_DISK_DEVICE_PATH  *RamDisk;
  UINT64                      StartingAddr;
  UINT64                      EndingAddr;

  StartingAddrStr = GetNextParamStr (&TextDeviceNode);
  EndingAddrStr   = GetNextParamStr (&TextDeviceNode);
  InstanceStr     = GetNextParamStr (&TextDeviceNode);

  RamDisk = (MEDIA_RAM_DISK_DEVICE_PATH *)CreateDeviceNode (
                                            MEDIA_DEVICE_PATH,
                                            MEDIA_RAM_DISK_DP,
                                            (UINT16)sizeof (MEDIA_RAM_DISK_DEVICE_PATH)
                                            );

  if (RamDisk != NULL) {
    Strtoi64 (StartingAddrStr, &StartingAddr);
    WriteUnaligned64 ((UINT64 *)&(RamDisk->StartingAddr[0]), StartingAddr);
    Strtoi64 (EndingAddrStr, &EndingAddr);
    WriteUnaligned64 ((UINT64 *)&(RamDisk->EndingAddr[0]), EndingAddr);
    RamDisk->Instance = (UINT16)Strtoi (InstanceStr);
    CopyGuid (&RamDisk->TypeGuid, &gEfiVirtualCdGuid);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)RamDisk;
}

/**
  Converts a text device path node to text persistent virtual disk device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created Text device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextPersistentVirtualDisk (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16                      *StartingAddrStr;
  CHAR16                      *EndingAddrStr;
  CHAR16                      *InstanceStr;
  MEDIA_RAM_DISK_DEVICE_PATH  *RamDisk;
  UINT64                      StartingAddr;
  UINT64                      EndingAddr;

  StartingAddrStr = GetNextParamStr (&TextDeviceNode);
  EndingAddrStr   = GetNextParamStr (&TextDeviceNode);
  InstanceStr     = GetNextParamStr (&TextDeviceNode);

  RamDisk = (MEDIA_RAM_DISK_DEVICE_PATH *)CreateDeviceNode (
                                            MEDIA_DEVICE_PATH,
                                            MEDIA_RAM_DISK_DP,
                                            (UINT16)sizeof (MEDIA_RAM_DISK_DEVICE_PATH)
                                            );

  if (RamDisk != NULL) {
    Strtoi64 (StartingAddrStr, &StartingAddr);
    WriteUnaligned64 ((UINT64 *)&(RamDisk->StartingAddr[0]), StartingAddr);
    Strtoi64 (EndingAddrStr, &EndingAddr);
    WriteUnaligned64 ((UINT64 *)&(RamDisk->EndingAddr[0]), EndingAddr);
    RamDisk->Instance = (UINT16)Strtoi (InstanceStr);
    CopyGuid (&RamDisk->TypeGuid, &gEfiPersistentVirtualDiskGuid);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)RamDisk;
}

/**
  Converts a text device path node to text persistent virtual cd device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created Text device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextPersistentVirtualCd (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16                      *StartingAddrStr;
  CHAR16                      *EndingAddrStr;
  CHAR16                      *InstanceStr;
  MEDIA_RAM_DISK_DEVICE_PATH  *RamDisk;
  UINT64                      StartingAddr;
  UINT64                      EndingAddr;

  StartingAddrStr = GetNextParamStr (&TextDeviceNode);
  EndingAddrStr   = GetNextParamStr (&TextDeviceNode);
  InstanceStr     = GetNextParamStr (&TextDeviceNode);

  RamDisk = (MEDIA_RAM_DISK_DEVICE_PATH *)CreateDeviceNode (
                                            MEDIA_DEVICE_PATH,
                                            MEDIA_RAM_DISK_DP,
                                            (UINT16)sizeof (MEDIA_RAM_DISK_DEVICE_PATH)
                                            );

  if (RamDisk != NULL) {
    Strtoi64 (StartingAddrStr, &StartingAddr);
    WriteUnaligned64 ((UINT64 *)&(RamDisk->StartingAddr[0]), StartingAddr);
    Strtoi64 (EndingAddrStr, &EndingAddr);
    WriteUnaligned64 ((UINT64 *)&(RamDisk->EndingAddr[0]), EndingAddr);
    RamDisk->Instance = (UINT16)Strtoi (InstanceStr);
    CopyGuid (&RamDisk->TypeGuid, &gEfiPersistentVirtualCdGuid);
  }

  return (EFI_DEVICE_PATH_PROTOCOL *)RamDisk;
}

/**
  Converts a BBS text device path node to BBS device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to BBS device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextBbsPath (
  IN CHAR16  *TextDeviceNode
  )
{
  return DevPathFromTextGenericPath (BBS_DEVICE_PATH, TextDeviceNode);
}

/**
  Converts a text device path node to BIOS Boot Specification device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created BIOS Boot Specification device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextBBS (
  IN CHAR16  *TextDeviceNode
  )
{
  CHAR16               *TypeStr;
  CHAR16               *IdStr;
  CHAR16               *FlagsStr;
  CHAR8                *AsciiStr;
  BBS_BBS_DEVICE_PATH  *Bbs;

  TypeStr  = GetNextParamStr (&TextDeviceNode);
  IdStr    = GetNextParamStr (&TextDeviceNode);
  FlagsStr = GetNextParamStr (&TextDeviceNode);
  Bbs      = (BBS_BBS_DEVICE_PATH *)CreateDeviceNode (
                                      BBS_DEVICE_PATH,
                                      BBS_BBS_DP,
                                      (UINT16)(sizeof (BBS_BBS_DEVICE_PATH) + StrLen (IdStr))
                                      );

  if (Bbs == NULL) {
    return (EFI_DEVICE_PATH_PROTOCOL *)Bbs;
  }

  if (StrCmp (TypeStr, "Floppy") == 0) {
    Bbs->DeviceType = BBS_TYPE_FLOPPY;
  } else if (StrCmp (TypeStr, "HD") == 0) {
    Bbs->DeviceType = BBS_TYPE_HARDDRIVE;
  } else if (StrCmp (TypeStr, "CDROM") == 0) {
    Bbs->DeviceType = BBS_TYPE_CDROM;
  } else if (StrCmp (TypeStr, "PCMCIA") == 0) {
    Bbs->DeviceType = BBS_TYPE_PCMCIA;
  } else if (StrCmp (TypeStr, "USB") == 0) {
    Bbs->DeviceType = BBS_TYPE_USB;
  } else if (StrCmp (TypeStr, "Network") == 0) {
    Bbs->DeviceType = BBS_TYPE_EMBEDDED_NETWORK;
  } else {
    Bbs->DeviceType = (UINT16)Strtoi (TypeStr);
  }

  AsciiStr = Bbs->String;
  StrToAscii (IdStr, &AsciiStr);

  Bbs->StatusFlag = (UINT16)Strtoi (FlagsStr);

  return (EFI_DEVICE_PATH_PROTOCOL *)Bbs;
}

/**
  Converts a text device path node to SATA device path structure.

  @param TextDeviceNode  The input Text device path node.

  @return A pointer to the newly-created SATA device path structure.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextSata (
  IN CHAR16  *TextDeviceNode
  )
{
  SATA_DEVICE_PATH  *Sata;
  CHAR16            *Param1;
  CHAR16            *Param2;
  CHAR16            *Param3;

  Param1 = GetNextParamStr (&TextDeviceNode);
  Param2 = GetNextParamStr (&TextDeviceNode);
  Param3 = GetNextParamStr (&TextDeviceNode);

  Sata = (SATA_DEVICE_PATH *)CreateDeviceNode (
                               MESSAGING_DEVICE_PATH,
                               MSG_SATA_DP,
                               (UINT16)sizeof (SATA_DEVICE_PATH)
                               );

  if (Sata == NULL) {
    return (EFI_DEVICE_PATH_PROTOCOL *)Sata;
  }

  Sata->HBAPortNumber = (UINT16)Strtoi (Param1);

  //
  // According to UEFI spec, if PMPN is not provided, the default is 0xFFFF
  //
  if (*Param2 == '\0' ) {
    Sata->PortMultiplierPortNumber = 0xFFFF;
  } else {
    Sata->PortMultiplierPortNumber = (UINT16)Strtoi (Param2);
  }

  Sata->Lun = (UINT16)Strtoi (Param3);

  return (EFI_DEVICE_PATH_PROTOCOL *)Sata;
}

GLOBAL_REMOVE_IF_UNREFERENCED DEVICE_PATH_FROM_TEXT_TABLE  mUefiDevicePathLibDevPathFromTextTable[] = {
  { "Path",                    DevPathFromTextPath                    },

  { "HardwarePath",            DevPathFromTextHardwarePath            },
  { "Pci",                     DevPathFromTextPci                     },
  { "PcCard",                  DevPathFromTextPcCard                  },
  { "MemoryMapped",            DevPathFromTextMemoryMapped            },
  { "VenHw",                   DevPathFromTextVenHw                   },
  { "Ctrl",                    DevPathFromTextCtrl                    },
  { "BMC",                     DevPathFromTextBmc                     },

  { "AcpiPath",                DevPathFromTextAcpiPath                },
  { "Acpi",                    DevPathFromTextAcpi                    },
  { "PciRoot",                 DevPathFromTextPciRoot                 },
  { "PcieRoot",                DevPathFromTextPcieRoot                },
  { "Floppy",                  DevPathFromTextFloppy                  },
  { "Keyboard",                DevPathFromTextKeyboard                },
  { "Serial",                  DevPathFromTextSerial                  },
  { "ParallelPort",            DevPathFromTextParallelPort            },
  { "AcpiEx",                  DevPathFromTextAcpiEx                  },
  { "AcpiExp",                 DevPathFromTextAcpiExp                 },
  { "AcpiAdr",                 DevPathFromTextAcpiAdr                 },

  { "Msg",                     DevPathFromTextMsg                     },
  { "Ata",                     DevPathFromTextAta                     },
  { "Scsi",                    DevPathFromTextScsi                    },
  { "Fibre",                   DevPathFromTextFibre                   },
  { "FibreEx",                 DevPathFromTextFibreEx                 },
  { "I1394",                   DevPathFromText1394                    },
  { "USB",                     DevPathFromTextUsb                     },
  { "I2O",                     DevPathFromTextI2O                     },
  { "Infiniband",              DevPathFromTextInfiniband              },
  { "VenMsg",                  DevPathFromTextVenMsg                  },
  { "VenPcAnsi",               DevPathFromTextVenPcAnsi               },
  { "VenVt100",                DevPathFromTextVenVt100                },
  { "VenVt100Plus",            DevPathFromTextVenVt100Plus            },
  { "VenUtf8",                 DevPathFromTextVenUtf8                 },
  { "UartFlowCtrl",            DevPathFromTextUartFlowCtrl            },
  { "SAS",                     DevPathFromTextSAS                     },
  { "SasEx",                   DevPathFromTextSasEx                   },
  { "NVMe",                    DevPathFromTextNVMe                    },
  { "UFS",                     DevPathFromTextUfs                     },
  { "SD",                      DevPathFromTextSd                      },
  { "eMMC",                    DevPathFromTextEmmc                    },
  { "DebugPort",               DevPathFromTextDebugPort               },
  { "MAC",                     DevPathFromTextMAC                     },
  { "IPv4",                    DevPathFromTextIPv4                    },
  { "IPv6",                    DevPathFromTextIPv6                    },
  { "Uart",                    DevPathFromTextUart                    },
  { "UsbClass",                DevPathFromTextUsbClass                },
  { "UsbAudio",                DevPathFromTextUsbAudio                },
  { "UsbCDCControl",           DevPathFromTextUsbCDCControl           },
  { "UsbHID",                  DevPathFromTextUsbHID                  },
  { "UsbImage",                DevPathFromTextUsbImage                },
  { "UsbPrinter",              DevPathFromTextUsbPrinter              },
  { "UsbMassStorage",          DevPathFromTextUsbMassStorage          },
  { "UsbHub",                  DevPathFromTextUsbHub                  },
  { "UsbCDCData",              DevPathFromTextUsbCDCData              },
  { "UsbSmartCard",            DevPathFromTextUsbSmartCard            },
  { "UsbVideo",                DevPathFromTextUsbVideo                },
  { "UsbDiagnostic",           DevPathFromTextUsbDiagnostic           },
  { "UsbWireless",             DevPathFromTextUsbWireless             },
  { "UsbDeviceFirmwareUpdate", DevPathFromTextUsbDeviceFirmwareUpdate },
  { "UsbIrdaBridge",           DevPathFromTextUsbIrdaBridge           },
  { "UsbTestAndMeasurement",   DevPathFromTextUsbTestAndMeasurement   },
  { "UsbWwid",                 DevPathFromTextUsbWwid                 },
  { "Unit",                    DevPathFromTextUnit                    },
  { "iSCSI",                   DevPathFromTextiSCSI                   },
  { "Vlan",                    DevPathFromTextVlan                    },
  { "Dns",                     DevPathFromTextDns                     },
  { "Uri",                     DevPathFromTextUri                     },
  { "Bluetooth",               DevPathFromTextBluetooth               },
  { "Wi-Fi",                   DevPathFromTextWiFi                    },
  { "BluetoothLE",             DevPathFromTextBluetoothLE             },
  { "MediaPath",               DevPathFromTextMediaPath               },
  { "HD",                      DevPathFromTextHD                      },
  { "CDROM",                   DevPathFromTextCDROM                   },
  { "VenMedia",                DevPathFromTextVenMedia                },
  { "Media",                   DevPathFromTextMedia                   },
  { "Fv",                      DevPathFromTextFv                      },
  { "FvFile",                  DevPathFromTextFvFile                  },
  { "File",                    DevPathFromTextFilePath                },
  { "Offset",                  DevPathFromTextRelativeOffsetRange     },
  { "RamDisk",                 DevPathFromTextRamDisk                 },
  { "VirtualDisk",             DevPathFromTextVirtualDisk             },
  { "VirtualCD",               DevPathFromTextVirtualCd               },
  { "PersistentVirtualDisk",   DevPathFromTextPersistentVirtualDisk   },
  { "PersistentVirtualCD",     DevPathFromTextPersistentVirtualCd     },

  { "BbsPath",                 DevPathFromTextBbsPath                 },
  { "BBS",                     DevPathFromTextBBS                     },
  { "Sata",                    DevPathFromTextSata                    },
  { NULL,                       NULL                                   }
};

/**
  Convert text to the binary representation of a device node.

  @param TextDeviceNode  TextDeviceNode points to the text representation of a device
                         node. Conversion starts with the first character and continues
                         until the first non-device node character.

  @return A pointer to the EFI device node or NULL if TextDeviceNode is NULL or there was
          insufficient memory or text unsupported.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
EFIAPI
UefiDevicePathLibConvertTextToDeviceNode (
  IN CONST CHAR16  *TextDeviceNode
  )
{
  DEVICE_PATH_FROM_TEXT     FromText;
  CHAR16                    *ParamStr;
  EFI_DEVICE_PATH_PROTOCOL  *DeviceNode;
  CHAR16                    *DeviceNodeStr;
  UINTN                     Index;

  if ((TextDeviceNode == NULL) || (IS_NULL (*TextDeviceNode))) {
    return NULL;
  }

  ParamStr      = NULL;
  FromText      = NULL;
  DeviceNodeStr = UefiDevicePathLibStrDuplicate (TextDeviceNode);
  ASSERT (DeviceNodeStr != NULL);

  for (Index = 0; mUefiDevicePathLibDevPathFromTextTable[Index].Function != NULL; Index++) {
    ParamStr = GetParamByNodeName (DeviceNodeStr, mUefiDevicePathLibDevPathFromTextTable[Index].DevicePathNodeText);
    if (ParamStr != NULL) {
      FromText = mUefiDevicePathLibDevPathFromTextTable[Index].Function;
      break;
    }
  }

  if (FromText == NULL) {
    //
    // A file path
    //
    FromText   = DevPathFromTextFilePath;
    DeviceNode = FromText (DeviceNodeStr);
  } else {
    DeviceNode = FromText (ParamStr);
    FreePool (ParamStr);
  }

  FreePool (DeviceNodeStr);

  return DeviceNode;
}

/**
  Convert text to the binary representation of a device path.


  @param TextDevicePath  TextDevicePath points to the text representation of a device
                         path. Conversion starts with the first character and continues
                         until the first non-device node character.

  @return A pointer to the allocated device path or NULL if TextDeviceNode is NULL or
          there was insufficient memory.

**/
static
EFI_DEVICE_PATH_PROTOCOL *
EFIAPI
UefiDevicePathLibConvertTextToDevicePath (
  IN CONST CHAR16  *TextDevicePath
  )
{
  EFI_DEVICE_PATH_PROTOCOL  *DeviceNode;
  EFI_DEVICE_PATH_PROTOCOL  *NewDevicePath;
  CHAR16                    *DevicePathStr;
  CHAR16                    *Str;
  CHAR16                    *DeviceNodeStr;
  BOOLEAN                   IsInstanceEnd;
  EFI_DEVICE_PATH_PROTOCOL  *DevicePath;

  if ((TextDevicePath == NULL) || (IS_NULL (*TextDevicePath))) {
    return NULL;
  }

  DevicePath = (EFI_DEVICE_PATH_PROTOCOL *)AllocatePool (END_DEVICE_PATH_LENGTH);

  if (DevicePath == NULL) {
    ASSERT (DevicePath != NULL);
    return NULL;
  }

  SetDevicePathEndNode (DevicePath);

  DevicePathStr = UefiDevicePathLibStrDuplicate (TextDevicePath);

  if (DevicePathStr == NULL) {
    return NULL;
  }

  Str = DevicePathStr;
  while ((DeviceNodeStr = GetNextDeviceNodeStr (&Str, &IsInstanceEnd)) != NULL) {
    DeviceNode = UefiDevicePathLibConvertTextToDeviceNode (DeviceNodeStr);

    NewDevicePath = AppendDevicePathNode (DevicePath, DeviceNode);
    if (DevicePath != NULL) {
      FreePool (DevicePath);
    }

    if (DeviceNode != NULL) {
      FreePool (DeviceNode);
    }

    DevicePath = NewDevicePath;

    if (IsInstanceEnd) {
      DeviceNode = (EFI_DEVICE_PATH_PROTOCOL *)AllocatePool (END_DEVICE_PATH_LENGTH);
      if (DeviceNode == NULL) {
        ASSERT (DeviceNode != NULL);
        return NULL;
      }

      SetDevicePathEndNode (DeviceNode);
      DeviceNode->SubType = END_INSTANCE_DEVICE_PATH_SUBTYPE;

      NewDevicePath = AppendDevicePathNode (DevicePath, DeviceNode);
      if (DevicePath != NULL) {
        FreePool (DevicePath);
      }

      if (DeviceNode != NULL) {
        FreePool (DeviceNode);
      }

      DevicePath = NewDevicePath;
    }
  }

  FreePool (DevicePathStr);
  return DevicePath;
}

ssize_t
efidp_parse_device_path(char *path, efidp out, size_t max)
{
	EFI_DEVICE_PATH_PROTOCOL *dp;
	UINTN len;

	dp = UefiDevicePathLibConvertTextToDevicePath (path);
	if (dp == NULL)
		return -1;
	len = GetDevicePathSize(dp);
	if (len > max) {
		free(dp);
		return -1;
	}
	memcpy(out, dp, len);
	free(dp);

	return len;
}