MdePkg: Apply uncrustify changes

[mirror_edk2.git] / MdePkg / Library / UefiDevicePathLib / DevicePathFromText.c

/** @file\r
  DevicePathFromText protocol as defined in the UEFI 2.0 specification.\r
\r
Copyright (c) 2013 - 2018, Intel Corporation. All rights reserved.<BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "UefiDevicePathLib.h"\r
\r
/**\r
\r
  Duplicates a string.\r
\r
  @param  Src  Source string.\r
\r
  @return The duplicated string.\r
\r
**/\r
CHAR16 *\r
UefiDevicePathLibStrDuplicate (\r
  IN CONST CHAR16  *Src\r
  )\r
{\r
  return AllocateCopyPool (StrSize (Src), Src);\r
}\r
\r
/**\r
\r
  Get parameter in a pair of parentheses follow the given node name.\r
  For example, given the "Pci(0,1)" and NodeName "Pci", it returns "0,1".\r
\r
  @param  Str      Device Path Text.\r
  @param  NodeName Name of the node.\r
\r
  @return Parameter text for the node.\r
\r
**/\r
CHAR16 *\r
GetParamByNodeName (\r
  IN CHAR16  *Str,\r
  IN CHAR16  *NodeName\r
  )\r
{\r
  CHAR16  *ParamStr;\r
  CHAR16  *StrPointer;\r
  UINTN   NodeNameLength;\r
  UINTN   ParameterLength;\r
\r
  //\r
  // Check whether the node name matchs\r
  //\r
  NodeNameLength = StrLen (NodeName);\r
  if (StrnCmp (Str, NodeName, NodeNameLength) != 0) {\r
    return NULL;\r
  }\r
\r
  ParamStr = Str + NodeNameLength;\r
  if (!IS_LEFT_PARENTH (*ParamStr)) {\r
    return NULL;\r
  }\r
\r
  //\r
  // Skip the found '(' and find first occurrence of ')'\r
  //\r
  ParamStr++;\r
  ParameterLength = 0;\r
  StrPointer      = ParamStr;\r
  while (!IS_NULL (*StrPointer)) {\r
    if (IS_RIGHT_PARENTH (*StrPointer)) {\r
      break;\r
    }\r
\r
    StrPointer++;\r
    ParameterLength++;\r
  }\r
\r
  if (IS_NULL (*StrPointer)) {\r
    //\r
    // ')' not found\r
    //\r
    return NULL;\r
  }\r
\r
  ParamStr = AllocateCopyPool ((ParameterLength + 1) * sizeof (CHAR16), ParamStr);\r
  if (ParamStr == NULL) {\r
    return NULL;\r
  }\r
\r
  //\r
  // Terminate the parameter string\r
  //\r
  ParamStr[ParameterLength] = L'\0';\r
\r
  return ParamStr;\r
}\r
\r
/**\r
  Gets current sub-string from a string list, before return\r
  the list header is moved to next sub-string. The sub-string is separated\r
  by the specified character. For example, the separator is ',', the string\r
  list is "2,0,3", it returns "2", the remain list move to "0,3"\r
\r
  @param  List        A string list separated by the specified separator\r
  @param  Separator   The separator character\r
\r
  @return A pointer to the current sub-string\r
\r
**/\r
CHAR16 *\r
SplitStr (\r
  IN OUT CHAR16  **List,\r
  IN     CHAR16  Separator\r
  )\r
{\r
  CHAR16  *Str;\r
  CHAR16  *ReturnStr;\r
\r
  Str       = *List;\r
  ReturnStr = Str;\r
\r
  if (IS_NULL (*Str)) {\r
    return ReturnStr;\r
  }\r
\r
  //\r
  // Find first occurrence of the separator\r
  //\r
  while (!IS_NULL (*Str)) {\r
    if (*Str == Separator) {\r
      break;\r
    }\r
\r
    Str++;\r
  }\r
\r
  if (*Str == Separator) {\r
    //\r
    // Find a sub-string, terminate it\r
    //\r
    *Str = L'\0';\r
    Str++;\r
  }\r
\r
  //\r
  // Move to next sub-string\r
  //\r
  *List = Str;\r
\r
  return ReturnStr;\r
}\r
\r
/**\r
  Gets the next parameter string from the list.\r
\r
  @param List            A string list separated by the specified separator\r
\r
  @return A pointer to the current sub-string\r
\r
**/\r
CHAR16 *\r
GetNextParamStr (\r
  IN OUT CHAR16  **List\r
  )\r
{\r
  //\r
  // The separator is comma\r
  //\r
  return SplitStr (List, L',');\r
}\r
\r
/**\r
  Get one device node from entire device path text.\r
\r
  @param DevicePath      On input, the current Device Path node; on output, the next device path node\r
  @param IsInstanceEnd   This node is the end of a device path instance\r
\r
  @return A device node text or NULL if no more device node available\r
\r
**/\r
CHAR16 *\r
GetNextDeviceNodeStr (\r
  IN OUT CHAR16   **DevicePath,\r
  OUT    BOOLEAN  *IsInstanceEnd\r
  )\r
{\r
  CHAR16  *Str;\r
  CHAR16  *ReturnStr;\r
  UINTN   ParenthesesStack;\r
\r
  Str = *DevicePath;\r
  if (IS_NULL (*Str)) {\r
    return NULL;\r
  }\r
\r
  //\r
  // Skip the leading '/', '(', ')' and ','\r
  //\r
  while (!IS_NULL (*Str)) {\r
    if (!IS_SLASH (*Str) &&\r
        !IS_COMMA (*Str) &&\r
        !IS_LEFT_PARENTH (*Str) &&\r
        !IS_RIGHT_PARENTH (*Str))\r
    {\r
      break;\r
    }\r
\r
    Str++;\r
  }\r
\r
  ReturnStr = Str;\r
\r
  //\r
  // Scan for the separator of this device node, '/' or ','\r
  //\r
  ParenthesesStack = 0;\r
  while (!IS_NULL (*Str)) {\r
    if ((IS_COMMA (*Str) || IS_SLASH (*Str)) && (ParenthesesStack == 0)) {\r
      break;\r
    }\r
\r
    if (IS_LEFT_PARENTH (*Str)) {\r
      ParenthesesStack++;\r
    } else if (IS_RIGHT_PARENTH (*Str)) {\r
      ParenthesesStack--;\r
    }\r
\r
    Str++;\r
  }\r
\r
  if (ParenthesesStack != 0) {\r
    //\r
    // The '(' doesn't pair with ')', invalid device path text\r
    //\r
    return NULL;\r
  }\r
\r
  if (IS_COMMA (*Str)) {\r
    *IsInstanceEnd = TRUE;\r
    *Str           = L'\0';\r
    Str++;\r
  } else {\r
    *IsInstanceEnd = FALSE;\r
    if (!IS_NULL (*Str)) {\r
      *Str = L'\0';\r
      Str++;\r
    }\r
  }\r
\r
  *DevicePath = Str;\r
\r
  return ReturnStr;\r
}\r
\r
/**\r
  Return whether the integer string is a hex string.\r
\r
  @param Str             The integer string\r
\r
  @retval TRUE   Hex string\r
  @retval FALSE  Decimal string\r
\r
**/\r
BOOLEAN\r
IsHexStr (\r
  IN CHAR16  *Str\r
  )\r
{\r
  //\r
  // skip preceeding white space\r
  //\r
  while ((*Str != 0) && *Str == L' ') {\r
    Str++;\r
  }\r
\r
  //\r
  // skip preceeding zeros\r
  //\r
  while ((*Str != 0) && *Str == L'0') {\r
    Str++;\r
  }\r
\r
  return (BOOLEAN)(*Str == L'x' || *Str == L'X');\r
}\r
\r
/**\r
\r
  Convert integer string to uint.\r
\r
  @param Str             The integer string. If leading with "0x" or "0X", it's hexadecimal.\r
\r
  @return A UINTN value represented by Str\r
\r
**/\r
UINTN\r
Strtoi (\r
  IN CHAR16  *Str\r
  )\r
{\r
  if (IsHexStr (Str)) {\r
    return StrHexToUintn (Str);\r
  } else {\r
    return StrDecimalToUintn (Str);\r
  }\r
}\r
\r
/**\r
\r
  Convert integer string to 64 bit data.\r
\r
  @param Str             The integer string. If leading with "0x" or "0X", it's hexadecimal.\r
  @param Data            A pointer to the UINT64 value represented by Str\r
\r
**/\r
VOID\r
Strtoi64 (\r
  IN  CHAR16  *Str,\r
  OUT UINT64  *Data\r
  )\r
{\r
  if (IsHexStr (Str)) {\r
    *Data = StrHexToUint64 (Str);\r
  } else {\r
    *Data = StrDecimalToUint64 (Str);\r
  }\r
}\r
\r
/**\r
  Converts a Unicode string to ASCII string.\r
\r
  @param Str             The equivalent Unicode string\r
  @param AsciiStr        On input, it points to destination ASCII string buffer; on output, it points\r
                         to the next ASCII string next to it\r
\r
**/\r
VOID\r
StrToAscii (\r
  IN     CHAR16  *Str,\r
  IN OUT CHAR8   **AsciiStr\r
  )\r
{\r
  CHAR8  *Dest;\r
\r
  Dest = *AsciiStr;\r
  while (!IS_NULL (*Str)) {\r
    *(Dest++) = (CHAR8)*(Str++);\r
  }\r
\r
  *Dest = 0;\r
\r
  //\r
  // Return the string next to it\r
  //\r
  *AsciiStr = Dest + 1;\r
}\r
\r
/**\r
  Converts a generic text device path node to device path structure.\r
\r
  @param Type            The type of the device path node.\r
  @param TextDeviceNode  The input text device path node.\r
\r
  @return A pointer to device path structure.\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextGenericPath (\r
  IN UINT8   Type,\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  EFI_DEVICE_PATH_PROTOCOL  *Node;\r
  CHAR16                    *SubtypeStr;\r
  CHAR16                    *DataStr;\r
  UINTN                     DataLength;\r
\r
  SubtypeStr = GetNextParamStr (&TextDeviceNode);\r
  DataStr    = GetNextParamStr (&TextDeviceNode);\r
\r
  if (DataStr == NULL) {\r
    DataLength = 0;\r
  } else {\r
    DataLength = StrLen (DataStr) / 2;\r
  }\r
\r
  Node = CreateDeviceNode (\r
           Type,\r
           (UINT8)Strtoi (SubtypeStr),\r
           (UINT16)(sizeof (EFI_DEVICE_PATH_PROTOCOL) + DataLength)\r
           );\r
\r
  StrHexToBytes (DataStr, DataLength * 2, (UINT8 *)(Node + 1), DataLength);\r
  return Node;\r
}\r
\r
/**\r
  Converts a generic text device path node to device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextPath (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16  *TypeStr;\r
\r
  TypeStr = GetNextParamStr (&TextDeviceNode);\r
\r
  return DevPathFromTextGenericPath ((UINT8)Strtoi (TypeStr), TextDeviceNode);\r
}\r
\r
/**\r
  Converts a generic hardware text device path node to Hardware device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to Hardware device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextHardwarePath (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  return DevPathFromTextGenericPath (HARDWARE_DEVICE_PATH, TextDeviceNode);\r
}\r
\r
/**\r
  Converts a text device path node to Hardware PCI device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to Hardware PCI device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextPci (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16           *FunctionStr;\r
  CHAR16           *DeviceStr;\r
  PCI_DEVICE_PATH  *Pci;\r
\r
  DeviceStr   = GetNextParamStr (&TextDeviceNode);\r
  FunctionStr = GetNextParamStr (&TextDeviceNode);\r
  Pci         = (PCI_DEVICE_PATH *)CreateDeviceNode (\r
                                     HARDWARE_DEVICE_PATH,\r
                                     HW_PCI_DP,\r
                                     (UINT16)sizeof (PCI_DEVICE_PATH)\r
                                     );\r
\r
  Pci->Function = (UINT8)Strtoi (FunctionStr);\r
  Pci->Device   = (UINT8)Strtoi (DeviceStr);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Pci;\r
}\r
\r
/**\r
  Converts a text device path node to Hardware PC card device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to Hardware PC card device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextPcCard (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16              *FunctionNumberStr;\r
  PCCARD_DEVICE_PATH  *Pccard;\r
\r
  FunctionNumberStr = GetNextParamStr (&TextDeviceNode);\r
  Pccard            = (PCCARD_DEVICE_PATH *)CreateDeviceNode (\r
                                              HARDWARE_DEVICE_PATH,\r
                                              HW_PCCARD_DP,\r
                                              (UINT16)sizeof (PCCARD_DEVICE_PATH)\r
                                              );\r
\r
  Pccard->FunctionNumber = (UINT8)Strtoi (FunctionNumberStr);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Pccard;\r
}\r
\r
/**\r
  Converts a text device path node to Hardware memory map device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to Hardware memory map device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextMemoryMapped (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16              *MemoryTypeStr;\r
  CHAR16              *StartingAddressStr;\r
  CHAR16              *EndingAddressStr;\r
  MEMMAP_DEVICE_PATH  *MemMap;\r
\r
  MemoryTypeStr      = GetNextParamStr (&TextDeviceNode);\r
  StartingAddressStr = GetNextParamStr (&TextDeviceNode);\r
  EndingAddressStr   = GetNextParamStr (&TextDeviceNode);\r
  MemMap             = (MEMMAP_DEVICE_PATH *)CreateDeviceNode (\r
                                               HARDWARE_DEVICE_PATH,\r
                                               HW_MEMMAP_DP,\r
                                               (UINT16)sizeof (MEMMAP_DEVICE_PATH)\r
                                               );\r
\r
  MemMap->MemoryType = (UINT32)Strtoi (MemoryTypeStr);\r
  Strtoi64 (StartingAddressStr, &MemMap->StartingAddress);\r
  Strtoi64 (EndingAddressStr, &MemMap->EndingAddress);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)MemMap;\r
}\r
\r
/**\r
  Converts a text device path node to Vendor device path structure based on the input Type\r
  and SubType.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
  @param Type            The type of device path node.\r
  @param SubType         The subtype of device path node.\r
\r
  @return A pointer to the newly-created Vendor device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
ConvertFromTextVendor (\r
  IN CHAR16  *TextDeviceNode,\r
  IN UINT8   Type,\r
  IN UINT8   SubType\r
  )\r
{\r
  CHAR16              *GuidStr;\r
  CHAR16              *DataStr;\r
  UINTN               Length;\r
  VENDOR_DEVICE_PATH  *Vendor;\r
\r
  GuidStr = GetNextParamStr (&TextDeviceNode);\r
\r
  DataStr = GetNextParamStr (&TextDeviceNode);\r
  Length  = StrLen (DataStr);\r
  //\r
  // Two hex characters make up 1 buffer byte\r
  //\r
  Length = (Length + 1) / 2;\r
\r
  Vendor = (VENDOR_DEVICE_PATH *)CreateDeviceNode (\r
                                   Type,\r
                                   SubType,\r
                                   (UINT16)(sizeof (VENDOR_DEVICE_PATH) + Length)\r
                                   );\r
\r
  StrToGuid (GuidStr, &Vendor->Guid);\r
  StrHexToBytes (DataStr, Length * 2, (UINT8 *)(Vendor + 1), Length);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Vendor;\r
}\r
\r
/**\r
  Converts a text device path node to Vendor Hardware device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created Vendor Hardware device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextVenHw (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  return ConvertFromTextVendor (\r
           TextDeviceNode,\r
           HARDWARE_DEVICE_PATH,\r
           HW_VENDOR_DP\r
           );\r
}\r
\r
/**\r
  Converts a text device path node to Hardware Controller device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created Hardware Controller device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextCtrl (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16                  *ControllerStr;\r
  CONTROLLER_DEVICE_PATH  *Controller;\r
\r
  ControllerStr = GetNextParamStr (&TextDeviceNode);\r
  Controller    = (CONTROLLER_DEVICE_PATH *)CreateDeviceNode (\r
                                              HARDWARE_DEVICE_PATH,\r
                                              HW_CONTROLLER_DP,\r
                                              (UINT16)sizeof (CONTROLLER_DEVICE_PATH)\r
                                              );\r
  Controller->ControllerNumber = (UINT32)Strtoi (ControllerStr);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Controller;\r
}\r
\r
/**\r
  Converts a text device path node to BMC device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created BMC device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextBmc (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16           *InterfaceTypeStr;\r
  CHAR16           *BaseAddressStr;\r
  BMC_DEVICE_PATH  *BmcDp;\r
\r
  InterfaceTypeStr = GetNextParamStr (&TextDeviceNode);\r
  BaseAddressStr   = GetNextParamStr (&TextDeviceNode);\r
  BmcDp            = (BMC_DEVICE_PATH *)CreateDeviceNode (\r
                                          HARDWARE_DEVICE_PATH,\r
                                          HW_BMC_DP,\r
                                          (UINT16)sizeof (BMC_DEVICE_PATH)\r
                                          );\r
\r
  BmcDp->InterfaceType = (UINT8)Strtoi (InterfaceTypeStr);\r
  WriteUnaligned64 (\r
    (UINT64 *)(&BmcDp->BaseAddress),\r
    StrHexToUint64 (BaseAddressStr)\r
    );\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)BmcDp;\r
}\r
\r
/**\r
  Converts a generic ACPI text device path node to ACPI device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to ACPI device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextAcpiPath (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  return DevPathFromTextGenericPath (ACPI_DEVICE_PATH, TextDeviceNode);\r
}\r
\r
/**\r
  Converts a string to EisaId.\r
\r
  @param Text   The input string.\r
\r
  @return UINT32 EISA ID.\r
**/\r
UINT32\r
EisaIdFromText (\r
  IN CHAR16  *Text\r
  )\r
{\r
  return (((Text[0] - 'A' + 1) & 0x1f) << 10)\r
         + (((Text[1] - 'A' + 1) & 0x1f) <<  5)\r
         + (((Text[2] - 'A' + 1) & 0x1f) <<  0)\r
         + (UINT32)(StrHexToUintn (&Text[3]) << 16)\r
  ;\r
}\r
\r
/**\r
  Converts a text device path node to ACPI HID device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created ACPI HID device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextAcpi (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16                *HIDStr;\r
  CHAR16                *UIDStr;\r
  ACPI_HID_DEVICE_PATH  *Acpi;\r
\r
  HIDStr = GetNextParamStr (&TextDeviceNode);\r
  UIDStr = GetNextParamStr (&TextDeviceNode);\r
  Acpi   = (ACPI_HID_DEVICE_PATH *)CreateDeviceNode (\r
                                     ACPI_DEVICE_PATH,\r
                                     ACPI_DP,\r
                                     (UINT16)sizeof (ACPI_HID_DEVICE_PATH)\r
                                     );\r
\r
  Acpi->HID = EisaIdFromText (HIDStr);\r
  Acpi->UID = (UINT32)Strtoi (UIDStr);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Acpi;\r
}\r
\r
/**\r
  Converts a text device path node to ACPI HID device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
  @param PnPId           The input plug and play identification.\r
\r
  @return A pointer to the newly-created ACPI HID device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
ConvertFromTextAcpi (\r
  IN CHAR16  *TextDeviceNode,\r
  IN UINT32  PnPId\r
  )\r
{\r
  CHAR16                *UIDStr;\r
  ACPI_HID_DEVICE_PATH  *Acpi;\r
\r
  UIDStr = GetNextParamStr (&TextDeviceNode);\r
  Acpi   = (ACPI_HID_DEVICE_PATH *)CreateDeviceNode (\r
                                     ACPI_DEVICE_PATH,\r
                                     ACPI_DP,\r
                                     (UINT16)sizeof (ACPI_HID_DEVICE_PATH)\r
                                     );\r
\r
  Acpi->HID = EFI_PNP_ID (PnPId);\r
  Acpi->UID = (UINT32)Strtoi (UIDStr);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Acpi;\r
}\r
\r
/**\r
  Converts a text device path node to PCI root device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created PCI root device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextPciRoot (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  return ConvertFromTextAcpi (TextDeviceNode, 0x0a03);\r
}\r
\r
/**\r
  Converts a text device path node to PCIE root device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created PCIE root device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextPcieRoot (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  return ConvertFromTextAcpi (TextDeviceNode, 0x0a08);\r
}\r
\r
/**\r
  Converts a text device path node to Floppy device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created Floppy device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextFloppy (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  return ConvertFromTextAcpi (TextDeviceNode, 0x0604);\r
}\r
\r
/**\r
  Converts a text device path node to Keyboard device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created  Keyboard device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextKeyboard (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  return ConvertFromTextAcpi (TextDeviceNode, 0x0301);\r
}\r
\r
/**\r
  Converts a text device path node to Serial device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created Serial device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextSerial (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  return ConvertFromTextAcpi (TextDeviceNode, 0x0501);\r
}\r
\r
/**\r
  Converts a text device path node to Parallel Port device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created Parallel Port device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextParallelPort (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  return ConvertFromTextAcpi (TextDeviceNode, 0x0401);\r
}\r
\r
/**\r
  Converts a text device path node to ACPI extension device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created ACPI extension device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextAcpiEx (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16                         *HIDStr;\r
  CHAR16                         *CIDStr;\r
  CHAR16                         *UIDStr;\r
  CHAR16                         *HIDSTRStr;\r
  CHAR16                         *CIDSTRStr;\r
  CHAR16                         *UIDSTRStr;\r
  CHAR8                          *AsciiStr;\r
  UINT16                         Length;\r
  ACPI_EXTENDED_HID_DEVICE_PATH  *AcpiEx;\r
\r
  HIDStr    = GetNextParamStr (&TextDeviceNode);\r
  CIDStr    = GetNextParamStr (&TextDeviceNode);\r
  UIDStr    = GetNextParamStr (&TextDeviceNode);\r
  HIDSTRStr = GetNextParamStr (&TextDeviceNode);\r
  CIDSTRStr = GetNextParamStr (&TextDeviceNode);\r
  UIDSTRStr = GetNextParamStr (&TextDeviceNode);\r
\r
  Length = (UINT16)(sizeof (ACPI_EXTENDED_HID_DEVICE_PATH) + StrLen (HIDSTRStr) + 1);\r
  Length = (UINT16)(Length + StrLen (UIDSTRStr) + 1);\r
  Length = (UINT16)(Length + StrLen (CIDSTRStr) + 1);\r
  AcpiEx = (ACPI_EXTENDED_HID_DEVICE_PATH *)CreateDeviceNode (\r
                                              ACPI_DEVICE_PATH,\r
                                              ACPI_EXTENDED_DP,\r
                                              Length\r
                                              );\r
\r
  AcpiEx->HID = EisaIdFromText (HIDStr);\r
  AcpiEx->CID = EisaIdFromText (CIDStr);\r
  AcpiEx->UID = (UINT32)Strtoi (UIDStr);\r
\r
  AsciiStr = (CHAR8 *)((UINT8 *)AcpiEx + sizeof (ACPI_EXTENDED_HID_DEVICE_PATH));\r
  StrToAscii (HIDSTRStr, &AsciiStr);\r
  StrToAscii (UIDSTRStr, &AsciiStr);\r
  StrToAscii (CIDSTRStr, &AsciiStr);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)AcpiEx;\r
}\r
\r
/**\r
  Converts a text device path node to ACPI extension device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created ACPI extension device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextAcpiExp (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16                         *HIDStr;\r
  CHAR16                         *CIDStr;\r
  CHAR16                         *UIDSTRStr;\r
  CHAR8                          *AsciiStr;\r
  UINT16                         Length;\r
  ACPI_EXTENDED_HID_DEVICE_PATH  *AcpiEx;\r
\r
  HIDStr    = GetNextParamStr (&TextDeviceNode);\r
  CIDStr    = GetNextParamStr (&TextDeviceNode);\r
  UIDSTRStr = GetNextParamStr (&TextDeviceNode);\r
  Length    = (UINT16)(sizeof (ACPI_EXTENDED_HID_DEVICE_PATH) + StrLen (UIDSTRStr) + 3);\r
  AcpiEx    = (ACPI_EXTENDED_HID_DEVICE_PATH *)CreateDeviceNode (\r
                                                 ACPI_DEVICE_PATH,\r
                                                 ACPI_EXTENDED_DP,\r
                                                 Length\r
                                                 );\r
\r
  AcpiEx->HID = EisaIdFromText (HIDStr);\r
  //\r
  // According to UEFI spec, the CID parametr is optional and has a default value of 0.\r
  // So when the CID parametr is not specified or specified as 0 in the text device node.\r
  // Set the CID to 0 in the ACPI extension device path structure.\r
  //\r
  if ((*CIDStr == L'\0') || (*CIDStr == L'0')) {\r
    AcpiEx->CID = 0;\r
  } else {\r
    AcpiEx->CID = EisaIdFromText (CIDStr);\r
  }\r
\r
  AcpiEx->UID = 0;\r
\r
  AsciiStr = (CHAR8 *)((UINT8 *)AcpiEx + sizeof (ACPI_EXTENDED_HID_DEVICE_PATH));\r
  //\r
  // HID string is NULL\r
  //\r
  *AsciiStr = '\0';\r
  //\r
  // Convert UID string\r
  //\r
  AsciiStr++;\r
  StrToAscii (UIDSTRStr, &AsciiStr);\r
  //\r
  // CID string is NULL\r
  //\r
  *AsciiStr = '\0';\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)AcpiEx;\r
}\r
\r
/**\r
  Converts a text device path node to ACPI _ADR device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created ACPI _ADR device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextAcpiAdr (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16                *DisplayDeviceStr;\r
  ACPI_ADR_DEVICE_PATH  *AcpiAdr;\r
  UINTN                 Index;\r
  UINTN                 Length;\r
\r
  AcpiAdr = (ACPI_ADR_DEVICE_PATH *)CreateDeviceNode (\r
                                      ACPI_DEVICE_PATH,\r
                                      ACPI_ADR_DP,\r
                                      (UINT16)sizeof (ACPI_ADR_DEVICE_PATH)\r
                                      );\r
  ASSERT (AcpiAdr != NULL);\r
\r
  for (Index = 0; ; Index++) {\r
    DisplayDeviceStr = GetNextParamStr (&TextDeviceNode);\r
    if (IS_NULL (*DisplayDeviceStr)) {\r
      break;\r
    }\r
\r
    if (Index > 0) {\r
      Length  = DevicePathNodeLength (AcpiAdr);\r
      AcpiAdr = ReallocatePool (\r
                  Length,\r
                  Length + sizeof (UINT32),\r
                  AcpiAdr\r
                  );\r
      ASSERT (AcpiAdr != NULL);\r
      SetDevicePathNodeLength (AcpiAdr, Length + sizeof (UINT32));\r
    }\r
\r
    (&AcpiAdr->ADR)[Index] = (UINT32)Strtoi (DisplayDeviceStr);\r
  }\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)AcpiAdr;\r
}\r
\r
/**\r
  Converts a generic messaging text device path node to messaging device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to messaging device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextMsg (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  return DevPathFromTextGenericPath (MESSAGING_DEVICE_PATH, TextDeviceNode);\r
}\r
\r
/**\r
  Converts a text device path node to Parallel Port device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created Parallel Port device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextAta (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16             *PrimarySecondaryStr;\r
  CHAR16             *SlaveMasterStr;\r
  CHAR16             *LunStr;\r
  ATAPI_DEVICE_PATH  *Atapi;\r
\r
  Atapi = (ATAPI_DEVICE_PATH *)CreateDeviceNode (\r
                                 MESSAGING_DEVICE_PATH,\r
                                 MSG_ATAPI_DP,\r
                                 (UINT16)sizeof (ATAPI_DEVICE_PATH)\r
                                 );\r
\r
  PrimarySecondaryStr = GetNextParamStr (&TextDeviceNode);\r
  SlaveMasterStr      = GetNextParamStr (&TextDeviceNode);\r
  LunStr              = GetNextParamStr (&TextDeviceNode);\r
\r
  if (StrCmp (PrimarySecondaryStr, L"Primary") == 0) {\r
    Atapi->PrimarySecondary = 0;\r
  } else if (StrCmp (PrimarySecondaryStr, L"Secondary") == 0) {\r
    Atapi->PrimarySecondary = 1;\r
  } else {\r
    Atapi->PrimarySecondary = (UINT8)Strtoi (PrimarySecondaryStr);\r
  }\r
\r
  if (StrCmp (SlaveMasterStr, L"Master") == 0) {\r
    Atapi->SlaveMaster = 0;\r
  } else if (StrCmp (SlaveMasterStr, L"Slave") == 0) {\r
    Atapi->SlaveMaster = 1;\r
  } else {\r
    Atapi->SlaveMaster = (UINT8)Strtoi (SlaveMasterStr);\r
  }\r
\r
  Atapi->Lun = (UINT16)Strtoi (LunStr);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Atapi;\r
}\r
\r
/**\r
  Converts a text device path node to SCSI device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created SCSI device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextScsi (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16            *PunStr;\r
  CHAR16            *LunStr;\r
  SCSI_DEVICE_PATH  *Scsi;\r
\r
  PunStr = GetNextParamStr (&TextDeviceNode);\r
  LunStr = GetNextParamStr (&TextDeviceNode);\r
  Scsi   = (SCSI_DEVICE_PATH *)CreateDeviceNode (\r
                                 MESSAGING_DEVICE_PATH,\r
                                 MSG_SCSI_DP,\r
                                 (UINT16)sizeof (SCSI_DEVICE_PATH)\r
                                 );\r
\r
  Scsi->Pun = (UINT16)Strtoi (PunStr);\r
  Scsi->Lun = (UINT16)Strtoi (LunStr);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Scsi;\r
}\r
\r
/**\r
  Converts a text device path node to Fibre device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created Fibre device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextFibre (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16                    *WWNStr;\r
  CHAR16                    *LunStr;\r
  FIBRECHANNEL_DEVICE_PATH  *Fibre;\r
\r
  WWNStr = GetNextParamStr (&TextDeviceNode);\r
  LunStr = GetNextParamStr (&TextDeviceNode);\r
  Fibre  = (FIBRECHANNEL_DEVICE_PATH *)CreateDeviceNode (\r
                                         MESSAGING_DEVICE_PATH,\r
                                         MSG_FIBRECHANNEL_DP,\r
                                         (UINT16)sizeof (FIBRECHANNEL_DEVICE_PATH)\r
                                         );\r
\r
  Fibre->Reserved = 0;\r
  Strtoi64 (WWNStr, &Fibre->WWN);\r
  Strtoi64 (LunStr, &Fibre->Lun);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Fibre;\r
}\r
\r
/**\r
  Converts a text device path node to FibreEx device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created FibreEx device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextFibreEx (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16                      *WWNStr;\r
  CHAR16                      *LunStr;\r
  FIBRECHANNELEX_DEVICE_PATH  *FibreEx;\r
\r
  WWNStr  = GetNextParamStr (&TextDeviceNode);\r
  LunStr  = GetNextParamStr (&TextDeviceNode);\r
  FibreEx = (FIBRECHANNELEX_DEVICE_PATH *)CreateDeviceNode (\r
                                            MESSAGING_DEVICE_PATH,\r
                                            MSG_FIBRECHANNELEX_DP,\r
                                            (UINT16)sizeof (FIBRECHANNELEX_DEVICE_PATH)\r
                                            );\r
\r
  FibreEx->Reserved = 0;\r
  Strtoi64 (WWNStr, (UINT64 *)(&FibreEx->WWN));\r
  Strtoi64 (LunStr, (UINT64 *)(&FibreEx->Lun));\r
\r
  *(UINT64 *)(&FibreEx->WWN) = SwapBytes64 (*(UINT64 *)(&FibreEx->WWN));\r
  *(UINT64 *)(&FibreEx->Lun) = SwapBytes64 (*(UINT64 *)(&FibreEx->Lun));\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)FibreEx;\r
}\r
\r
/**\r
  Converts a text device path node to 1394 device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created 1394 device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromText1394 (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16             *GuidStr;\r
  F1394_DEVICE_PATH  *F1394DevPath;\r
\r
  GuidStr      = GetNextParamStr (&TextDeviceNode);\r
  F1394DevPath = (F1394_DEVICE_PATH *)CreateDeviceNode (\r
                                        MESSAGING_DEVICE_PATH,\r
                                        MSG_1394_DP,\r
                                        (UINT16)sizeof (F1394_DEVICE_PATH)\r
                                        );\r
\r
  F1394DevPath->Reserved = 0;\r
  F1394DevPath->Guid     = StrHexToUint64 (GuidStr);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)F1394DevPath;\r
}\r
\r
/**\r
  Converts a text device path node to USB device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created USB device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextUsb (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16           *PortStr;\r
  CHAR16           *InterfaceStr;\r
  USB_DEVICE_PATH  *Usb;\r
\r
  PortStr      = GetNextParamStr (&TextDeviceNode);\r
  InterfaceStr = GetNextParamStr (&TextDeviceNode);\r
  Usb          = (USB_DEVICE_PATH *)CreateDeviceNode (\r
                                      MESSAGING_DEVICE_PATH,\r
                                      MSG_USB_DP,\r
                                      (UINT16)sizeof (USB_DEVICE_PATH)\r
                                      );\r
\r
  Usb->ParentPortNumber = (UINT8)Strtoi (PortStr);\r
  Usb->InterfaceNumber  = (UINT8)Strtoi (InterfaceStr);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Usb;\r
}\r
\r
/**\r
  Converts a text device path node to I20 device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created I20 device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextI2O (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16           *TIDStr;\r
  I2O_DEVICE_PATH  *I2ODevPath;\r
\r
  TIDStr     = GetNextParamStr (&TextDeviceNode);\r
  I2ODevPath = (I2O_DEVICE_PATH *)CreateDeviceNode (\r
                                    MESSAGING_DEVICE_PATH,\r
                                    MSG_I2O_DP,\r
                                    (UINT16)sizeof (I2O_DEVICE_PATH)\r
                                    );\r
\r
  I2ODevPath->Tid = (UINT32)Strtoi (TIDStr);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)I2ODevPath;\r
}\r
\r
/**\r
  Converts a text device path node to Infini Band device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created Infini Band device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextInfiniband (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16                  *FlagsStr;\r
  CHAR16                  *GuidStr;\r
  CHAR16                  *SidStr;\r
  CHAR16                  *TidStr;\r
  CHAR16                  *DidStr;\r
  INFINIBAND_DEVICE_PATH  *InfiniBand;\r
\r
  FlagsStr   = GetNextParamStr (&TextDeviceNode);\r
  GuidStr    = GetNextParamStr (&TextDeviceNode);\r
  SidStr     = GetNextParamStr (&TextDeviceNode);\r
  TidStr     = GetNextParamStr (&TextDeviceNode);\r
  DidStr     = GetNextParamStr (&TextDeviceNode);\r
  InfiniBand = (INFINIBAND_DEVICE_PATH *)CreateDeviceNode (\r
                                           MESSAGING_DEVICE_PATH,\r
                                           MSG_INFINIBAND_DP,\r
                                           (UINT16)sizeof (INFINIBAND_DEVICE_PATH)\r
                                           );\r
\r
  InfiniBand->ResourceFlags = (UINT32)Strtoi (FlagsStr);\r
  StrToGuid (GuidStr, (EFI_GUID *)InfiniBand->PortGid);\r
  Strtoi64 (SidStr, &InfiniBand->ServiceId);\r
  Strtoi64 (TidStr, &InfiniBand->TargetPortId);\r
  Strtoi64 (DidStr, &InfiniBand->DeviceId);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)InfiniBand;\r
}\r
\r
/**\r
  Converts a text device path node to Vendor-Defined Messaging device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created Vendor-Defined Messaging device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextVenMsg (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  return ConvertFromTextVendor (\r
           TextDeviceNode,\r
           MESSAGING_DEVICE_PATH,\r
           MSG_VENDOR_DP\r
           );\r
}\r
\r
/**\r
  Converts a text device path node to Vendor defined PC-ANSI device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created Vendor defined PC-ANSI device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextVenPcAnsi (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  VENDOR_DEVICE_PATH  *Vendor;\r
\r
  Vendor = (VENDOR_DEVICE_PATH *)CreateDeviceNode (\r
                                   MESSAGING_DEVICE_PATH,\r
                                   MSG_VENDOR_DP,\r
                                   (UINT16)sizeof (VENDOR_DEVICE_PATH)\r
                                   );\r
  CopyGuid (&Vendor->Guid, &gEfiPcAnsiGuid);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Vendor;\r
}\r
\r
/**\r
  Converts a text device path node to Vendor defined VT100 device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created Vendor defined VT100 device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextVenVt100 (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  VENDOR_DEVICE_PATH  *Vendor;\r
\r
  Vendor = (VENDOR_DEVICE_PATH *)CreateDeviceNode (\r
                                   MESSAGING_DEVICE_PATH,\r
                                   MSG_VENDOR_DP,\r
                                   (UINT16)sizeof (VENDOR_DEVICE_PATH)\r
                                   );\r
  CopyGuid (&Vendor->Guid, &gEfiVT100Guid);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Vendor;\r
}\r
\r
/**\r
  Converts a text device path node to Vendor defined VT100 Plus device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created Vendor defined VT100 Plus device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextVenVt100Plus (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  VENDOR_DEVICE_PATH  *Vendor;\r
\r
  Vendor = (VENDOR_DEVICE_PATH *)CreateDeviceNode (\r
                                   MESSAGING_DEVICE_PATH,\r
                                   MSG_VENDOR_DP,\r
                                   (UINT16)sizeof (VENDOR_DEVICE_PATH)\r
                                   );\r
  CopyGuid (&Vendor->Guid, &gEfiVT100PlusGuid);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Vendor;\r
}\r
\r
/**\r
  Converts a text device path node to Vendor defined UTF8 device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created Vendor defined UTF8 device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextVenUtf8 (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  VENDOR_DEVICE_PATH  *Vendor;\r
\r
  Vendor = (VENDOR_DEVICE_PATH *)CreateDeviceNode (\r
                                   MESSAGING_DEVICE_PATH,\r
                                   MSG_VENDOR_DP,\r
                                   (UINT16)sizeof (VENDOR_DEVICE_PATH)\r
                                   );\r
  CopyGuid (&Vendor->Guid, &gEfiVTUTF8Guid);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Vendor;\r
}\r
\r
/**\r
  Converts a text device path node to UART Flow Control device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created UART Flow Control device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextUartFlowCtrl (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16                         *ValueStr;\r
  UART_FLOW_CONTROL_DEVICE_PATH  *UartFlowControl;\r
\r
  ValueStr        = GetNextParamStr (&TextDeviceNode);\r
  UartFlowControl = (UART_FLOW_CONTROL_DEVICE_PATH *)CreateDeviceNode (\r
                                                       MESSAGING_DEVICE_PATH,\r
                                                       MSG_VENDOR_DP,\r
                                                       (UINT16)sizeof (UART_FLOW_CONTROL_DEVICE_PATH)\r
                                                       );\r
\r
  CopyGuid (&UartFlowControl->Guid, &gEfiUartDevicePathGuid);\r
  if (StrCmp (ValueStr, L"XonXoff") == 0) {\r
    UartFlowControl->FlowControlMap = 2;\r
  } else if (StrCmp (ValueStr, L"Hardware") == 0) {\r
    UartFlowControl->FlowControlMap = 1;\r
  } else {\r
    UartFlowControl->FlowControlMap = 0;\r
  }\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)UartFlowControl;\r
}\r
\r
/**\r
  Converts a text device path node to Serial Attached SCSI device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created Serial Attached SCSI device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextSAS (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16           *AddressStr;\r
  CHAR16           *LunStr;\r
  CHAR16           *RTPStr;\r
  CHAR16           *SASSATAStr;\r
  CHAR16           *LocationStr;\r
  CHAR16           *ConnectStr;\r
  CHAR16           *DriveBayStr;\r
  CHAR16           *ReservedStr;\r
  UINT16           Info;\r
  UINT16           Uint16;\r
  SAS_DEVICE_PATH  *Sas;\r
\r
  AddressStr  = GetNextParamStr (&TextDeviceNode);\r
  LunStr      = GetNextParamStr (&TextDeviceNode);\r
  RTPStr      = GetNextParamStr (&TextDeviceNode);\r
  SASSATAStr  = GetNextParamStr (&TextDeviceNode);\r
  LocationStr = GetNextParamStr (&TextDeviceNode);\r
  ConnectStr  = GetNextParamStr (&TextDeviceNode);\r
  DriveBayStr = GetNextParamStr (&TextDeviceNode);\r
  ReservedStr = GetNextParamStr (&TextDeviceNode);\r
  Sas         = (SAS_DEVICE_PATH *)CreateDeviceNode (\r
                                     MESSAGING_DEVICE_PATH,\r
                                     MSG_VENDOR_DP,\r
                                     (UINT16)sizeof (SAS_DEVICE_PATH)\r
                                     );\r
\r
  CopyGuid (&Sas->Guid, &gEfiSasDevicePathGuid);\r
  Strtoi64 (AddressStr, &Sas->SasAddress);\r
  Strtoi64 (LunStr, &Sas->Lun);\r
  Sas->RelativeTargetPort = (UINT16)Strtoi (RTPStr);\r
\r
  if (StrCmp (SASSATAStr, L"NoTopology") == 0) {\r
    Info = 0x0;\r
  } else if ((StrCmp (SASSATAStr, L"SATA") == 0) || (StrCmp (SASSATAStr, L"SAS") == 0)) {\r
    Uint16 = (UINT16)Strtoi (DriveBayStr);\r
    if (Uint16 == 0) {\r
      Info = 0x1;\r
    } else {\r
      Info = (UINT16)(0x2 | ((Uint16 - 1) << 8));\r
    }\r
\r
    if (StrCmp (SASSATAStr, L"SATA") == 0) {\r
      Info |= BIT4;\r
    }\r
\r
    //\r
    // Location is an integer between 0 and 1 or else\r
    // the keyword Internal (0) or External (1).\r
    //\r
    if (StrCmp (LocationStr, L"External") == 0) {\r
      Uint16 = 1;\r
    } else if (StrCmp (LocationStr, L"Internal") == 0) {\r
      Uint16 = 0;\r
    } else {\r
      Uint16 = ((UINT16)Strtoi (LocationStr) & BIT0);\r
    }\r
\r
    Info |= (Uint16 << 5);\r
\r
    //\r
    // Connect is an integer between 0 and 3 or else\r
    // the keyword Direct (0) or Expanded (1).\r
    //\r
    if (StrCmp (ConnectStr, L"Expanded") == 0) {\r
      Uint16 = 1;\r
    } else if (StrCmp (ConnectStr, L"Direct") == 0) {\r
      Uint16 = 0;\r
    } else {\r
      Uint16 = ((UINT16)Strtoi (ConnectStr) & (BIT0 | BIT1));\r
    }\r
\r
    Info |= (Uint16 << 6);\r
  } else {\r
    Info = (UINT16)Strtoi (SASSATAStr);\r
  }\r
\r
  Sas->DeviceTopology = Info;\r
  Sas->Reserved       = (UINT32)Strtoi (ReservedStr);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Sas;\r
}\r
\r
/**\r
  Converts a text device path node to Serial Attached SCSI Ex device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created Serial Attached SCSI Ex device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextSasEx (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16             *AddressStr;\r
  CHAR16             *LunStr;\r
  CHAR16             *RTPStr;\r
  CHAR16             *SASSATAStr;\r
  CHAR16             *LocationStr;\r
  CHAR16             *ConnectStr;\r
  CHAR16             *DriveBayStr;\r
  UINT16             Info;\r
  UINT16             Uint16;\r
  UINT64             SasAddress;\r
  UINT64             Lun;\r
  SASEX_DEVICE_PATH  *SasEx;\r
\r
  AddressStr  = GetNextParamStr (&TextDeviceNode);\r
  LunStr      = GetNextParamStr (&TextDeviceNode);\r
  RTPStr      = GetNextParamStr (&TextDeviceNode);\r
  SASSATAStr  = GetNextParamStr (&TextDeviceNode);\r
  LocationStr = GetNextParamStr (&TextDeviceNode);\r
  ConnectStr  = GetNextParamStr (&TextDeviceNode);\r
  DriveBayStr = GetNextParamStr (&TextDeviceNode);\r
  SasEx       = (SASEX_DEVICE_PATH *)CreateDeviceNode (\r
                                       MESSAGING_DEVICE_PATH,\r
                                       MSG_SASEX_DP,\r
                                       (UINT16)sizeof (SASEX_DEVICE_PATH)\r
                                       );\r
\r
  Strtoi64 (AddressStr, &SasAddress);\r
  Strtoi64 (LunStr, &Lun);\r
  WriteUnaligned64 ((UINT64 *)&SasEx->SasAddress, SwapBytes64 (SasAddress));\r
  WriteUnaligned64 ((UINT64 *)&SasEx->Lun, SwapBytes64 (Lun));\r
  SasEx->RelativeTargetPort = (UINT16)Strtoi (RTPStr);\r
\r
  if (StrCmp (SASSATAStr, L"NoTopology") == 0) {\r
    Info = 0x0;\r
  } else if ((StrCmp (SASSATAStr, L"SATA") == 0) || (StrCmp (SASSATAStr, L"SAS") == 0)) {\r
    Uint16 = (UINT16)Strtoi (DriveBayStr);\r
    if (Uint16 == 0) {\r
      Info = 0x1;\r
    } else {\r
      Info = (UINT16)(0x2 | ((Uint16 - 1) << 8));\r
    }\r
\r
    if (StrCmp (SASSATAStr, L"SATA") == 0) {\r
      Info |= BIT4;\r
    }\r
\r
    //\r
    // Location is an integer between 0 and 1 or else\r
    // the keyword Internal (0) or External (1).\r
    //\r
    if (StrCmp (LocationStr, L"External") == 0) {\r
      Uint16 = 1;\r
    } else if (StrCmp (LocationStr, L"Internal") == 0) {\r
      Uint16 = 0;\r
    } else {\r
      Uint16 = ((UINT16)Strtoi (LocationStr) & BIT0);\r
    }\r
\r
    Info |= (Uint16 << 5);\r
\r
    //\r
    // Connect is an integer between 0 and 3 or else\r
    // the keyword Direct (0) or Expanded (1).\r
    //\r
    if (StrCmp (ConnectStr, L"Expanded") == 0) {\r
      Uint16 = 1;\r
    } else if (StrCmp (ConnectStr, L"Direct") == 0) {\r
      Uint16 = 0;\r
    } else {\r
      Uint16 = ((UINT16)Strtoi (ConnectStr) & (BIT0 | BIT1));\r
    }\r
\r
    Info |= (Uint16 << 6);\r
  } else {\r
    Info = (UINT16)Strtoi (SASSATAStr);\r
  }\r
\r
  SasEx->DeviceTopology = Info;\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)SasEx;\r
}\r
\r
/**\r
  Converts a text device path node to NVM Express Namespace device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created NVM Express Namespace device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextNVMe (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16                      *NamespaceIdStr;\r
  CHAR16                      *NamespaceUuidStr;\r
  NVME_NAMESPACE_DEVICE_PATH  *Nvme;\r
  UINT8                       *Uuid;\r
  UINTN                       Index;\r
\r
  NamespaceIdStr   = GetNextParamStr (&TextDeviceNode);\r
  NamespaceUuidStr = GetNextParamStr (&TextDeviceNode);\r
  Nvme             = (NVME_NAMESPACE_DEVICE_PATH *)CreateDeviceNode (\r
                                                     MESSAGING_DEVICE_PATH,\r
                                                     MSG_NVME_NAMESPACE_DP,\r
                                                     (UINT16)sizeof (NVME_NAMESPACE_DEVICE_PATH)\r
                                                     );\r
\r
  Nvme->NamespaceId = (UINT32)Strtoi (NamespaceIdStr);\r
  Uuid              = (UINT8 *)&Nvme->NamespaceUuid;\r
\r
  Index = sizeof (Nvme->NamespaceUuid) / sizeof (UINT8);\r
  while (Index-- != 0) {\r
    Uuid[Index] = (UINT8)StrHexToUintn (SplitStr (&NamespaceUuidStr, L'-'));\r
  }\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Nvme;\r
}\r
\r
/**\r
  Converts a text device path node to UFS device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created UFS device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextUfs (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16           *PunStr;\r
  CHAR16           *LunStr;\r
  UFS_DEVICE_PATH  *Ufs;\r
\r
  PunStr = GetNextParamStr (&TextDeviceNode);\r
  LunStr = GetNextParamStr (&TextDeviceNode);\r
  Ufs    = (UFS_DEVICE_PATH *)CreateDeviceNode (\r
                                MESSAGING_DEVICE_PATH,\r
                                MSG_UFS_DP,\r
                                (UINT16)sizeof (UFS_DEVICE_PATH)\r
                                );\r
\r
  Ufs->Pun = (UINT8)Strtoi (PunStr);\r
  Ufs->Lun = (UINT8)Strtoi (LunStr);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Ufs;\r
}\r
\r
/**\r
  Converts a text device path node to SD (Secure Digital) device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created SD device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextSd (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16          *SlotNumberStr;\r
  SD_DEVICE_PATH  *Sd;\r
\r
  SlotNumberStr = GetNextParamStr (&TextDeviceNode);\r
  Sd            = (SD_DEVICE_PATH *)CreateDeviceNode (\r
                                      MESSAGING_DEVICE_PATH,\r
                                      MSG_SD_DP,\r
                                      (UINT16)sizeof (SD_DEVICE_PATH)\r
                                      );\r
\r
  Sd->SlotNumber = (UINT8)Strtoi (SlotNumberStr);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Sd;\r
}\r
\r
/**\r
  Converts a text device path node to EMMC (Embedded MMC) device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created EMMC device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextEmmc (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16            *SlotNumberStr;\r
  EMMC_DEVICE_PATH  *Emmc;\r
\r
  SlotNumberStr = GetNextParamStr (&TextDeviceNode);\r
  Emmc          = (EMMC_DEVICE_PATH *)CreateDeviceNode (\r
                                        MESSAGING_DEVICE_PATH,\r
                                        MSG_EMMC_DP,\r
                                        (UINT16)sizeof (EMMC_DEVICE_PATH)\r
                                        );\r
\r
  Emmc->SlotNumber = (UINT8)Strtoi (SlotNumberStr);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Emmc;\r
}\r
\r
/**\r
  Converts a text device path node to Debug Port device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created Debug Port device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextDebugPort (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  VENDOR_DEVICE_PATH  *Vend;\r
\r
  Vend = (VENDOR_DEVICE_PATH *)CreateDeviceNode (\r
                                 MESSAGING_DEVICE_PATH,\r
                                 MSG_VENDOR_DP,\r
                                 (UINT16)sizeof (VENDOR_DEVICE_PATH)\r
                                 );\r
\r
  CopyGuid (&Vend->Guid, &gEfiDebugPortProtocolGuid);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Vend;\r
}\r
\r
/**\r
  Converts a text device path node to MAC device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created MAC device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextMAC (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16                *AddressStr;\r
  CHAR16                *IfTypeStr;\r
  UINTN                 Length;\r
  MAC_ADDR_DEVICE_PATH  *MACDevPath;\r
\r
  AddressStr = GetNextParamStr (&TextDeviceNode);\r
  IfTypeStr  = GetNextParamStr (&TextDeviceNode);\r
  MACDevPath = (MAC_ADDR_DEVICE_PATH *)CreateDeviceNode (\r
                                         MESSAGING_DEVICE_PATH,\r
                                         MSG_MAC_ADDR_DP,\r
                                         (UINT16)sizeof (MAC_ADDR_DEVICE_PATH)\r
                                         );\r
\r
  MACDevPath->IfType = (UINT8)Strtoi (IfTypeStr);\r
\r
  Length = sizeof (EFI_MAC_ADDRESS);\r
  if ((MACDevPath->IfType == 0x01) || (MACDevPath->IfType == 0x00)) {\r
    Length = 6;\r
  }\r
\r
  StrHexToBytes (AddressStr, Length * 2, MACDevPath->MacAddress.Addr, Length);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)MACDevPath;\r
}\r
\r
/**\r
  Converts a text format to the network protocol ID.\r
\r
  @param Text  String of protocol field.\r
\r
  @return Network protocol ID .\r
\r
**/\r
UINTN\r
NetworkProtocolFromText (\r
  IN CHAR16  *Text\r
  )\r
{\r
  if (StrCmp (Text, L"UDP") == 0) {\r
    return RFC_1700_UDP_PROTOCOL;\r
  }\r
\r
  if (StrCmp (Text, L"TCP") == 0) {\r
    return RFC_1700_TCP_PROTOCOL;\r
  }\r
\r
  return Strtoi (Text);\r
}\r
\r
/**\r
  Converts a text device path node to IPV4 device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created IPV4 device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextIPv4 (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16            *RemoteIPStr;\r
  CHAR16            *ProtocolStr;\r
  CHAR16            *TypeStr;\r
  CHAR16            *LocalIPStr;\r
  CHAR16            *GatewayIPStr;\r
  CHAR16            *SubnetMaskStr;\r
  IPv4_DEVICE_PATH  *IPv4;\r
\r
  RemoteIPStr   = GetNextParamStr (&TextDeviceNode);\r
  ProtocolStr   = GetNextParamStr (&TextDeviceNode);\r
  TypeStr       = GetNextParamStr (&TextDeviceNode);\r
  LocalIPStr    = GetNextParamStr (&TextDeviceNode);\r
  GatewayIPStr  = GetNextParamStr (&TextDeviceNode);\r
  SubnetMaskStr = GetNextParamStr (&TextDeviceNode);\r
  IPv4          = (IPv4_DEVICE_PATH *)CreateDeviceNode (\r
                                        MESSAGING_DEVICE_PATH,\r
                                        MSG_IPv4_DP,\r
                                        (UINT16)sizeof (IPv4_DEVICE_PATH)\r
                                        );\r
\r
  StrToIpv4Address (RemoteIPStr, NULL, &IPv4->RemoteIpAddress, NULL);\r
  IPv4->Protocol = (UINT16)NetworkProtocolFromText (ProtocolStr);\r
  if (StrCmp (TypeStr, L"Static") == 0) {\r
    IPv4->StaticIpAddress = TRUE;\r
  } else {\r
    IPv4->StaticIpAddress = FALSE;\r
  }\r
\r
  StrToIpv4Address (LocalIPStr, NULL, &IPv4->LocalIpAddress, NULL);\r
  if (!IS_NULL (*GatewayIPStr) && !IS_NULL (*SubnetMaskStr)) {\r
    StrToIpv4Address (GatewayIPStr, NULL, &IPv4->GatewayIpAddress, NULL);\r
    StrToIpv4Address (SubnetMaskStr, NULL, &IPv4->SubnetMask, NULL);\r
  } else {\r
    ZeroMem (&IPv4->GatewayIpAddress, sizeof (IPv4->GatewayIpAddress));\r
    ZeroMem (&IPv4->SubnetMask, sizeof (IPv4->SubnetMask));\r
  }\r
\r
  IPv4->LocalPort  = 0;\r
  IPv4->RemotePort = 0;\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)IPv4;\r
}\r
\r
/**\r
  Converts a text device path node to IPV6 device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created IPV6 device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextIPv6 (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16            *RemoteIPStr;\r
  CHAR16            *ProtocolStr;\r
  CHAR16            *TypeStr;\r
  CHAR16            *LocalIPStr;\r
  CHAR16            *GatewayIPStr;\r
  CHAR16            *PrefixLengthStr;\r
  IPv6_DEVICE_PATH  *IPv6;\r
\r
  RemoteIPStr     = GetNextParamStr (&TextDeviceNode);\r
  ProtocolStr     = GetNextParamStr (&TextDeviceNode);\r
  TypeStr         = GetNextParamStr (&TextDeviceNode);\r
  LocalIPStr      = GetNextParamStr (&TextDeviceNode);\r
  PrefixLengthStr = GetNextParamStr (&TextDeviceNode);\r
  GatewayIPStr    = GetNextParamStr (&TextDeviceNode);\r
  IPv6            = (IPv6_DEVICE_PATH *)CreateDeviceNode (\r
                                          MESSAGING_DEVICE_PATH,\r
                                          MSG_IPv6_DP,\r
                                          (UINT16)sizeof (IPv6_DEVICE_PATH)\r
                                          );\r
\r
  StrToIpv6Address (RemoteIPStr, NULL, &IPv6->RemoteIpAddress, NULL);\r
  IPv6->Protocol = (UINT16)NetworkProtocolFromText (ProtocolStr);\r
  if (StrCmp (TypeStr, L"Static") == 0) {\r
    IPv6->IpAddressOrigin = 0;\r
  } else if (StrCmp (TypeStr, L"StatelessAutoConfigure") == 0) {\r
    IPv6->IpAddressOrigin = 1;\r
  } else {\r
    IPv6->IpAddressOrigin = 2;\r
  }\r
\r
  StrToIpv6Address (LocalIPStr, NULL, &IPv6->LocalIpAddress, NULL);\r
  if (!IS_NULL (*GatewayIPStr) && !IS_NULL (*PrefixLengthStr)) {\r
    StrToIpv6Address (GatewayIPStr, NULL, &IPv6->GatewayIpAddress, NULL);\r
    IPv6->PrefixLength = (UINT8)Strtoi (PrefixLengthStr);\r
  } else {\r
    ZeroMem (&IPv6->GatewayIpAddress, sizeof (IPv6->GatewayIpAddress));\r
    IPv6->PrefixLength = 0;\r
  }\r
\r
  IPv6->LocalPort  = 0;\r
  IPv6->RemotePort = 0;\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)IPv6;\r
}\r
\r
/**\r
  Converts a text device path node to UART device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created UART device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextUart (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16            *BaudStr;\r
  CHAR16            *DataBitsStr;\r
  CHAR16            *ParityStr;\r
  CHAR16            *StopBitsStr;\r
  UART_DEVICE_PATH  *Uart;\r
\r
  BaudStr     = GetNextParamStr (&TextDeviceNode);\r
  DataBitsStr = GetNextParamStr (&TextDeviceNode);\r
  ParityStr   = GetNextParamStr (&TextDeviceNode);\r
  StopBitsStr = GetNextParamStr (&TextDeviceNode);\r
  Uart        = (UART_DEVICE_PATH *)CreateDeviceNode (\r
                                      MESSAGING_DEVICE_PATH,\r
                                      MSG_UART_DP,\r
                                      (UINT16)sizeof (UART_DEVICE_PATH)\r
                                      );\r
\r
  if (StrCmp (BaudStr, L"DEFAULT") == 0) {\r
    Uart->BaudRate = 115200;\r
  } else {\r
    Strtoi64 (BaudStr, &Uart->BaudRate);\r
  }\r
\r
  Uart->DataBits = (UINT8)((StrCmp (DataBitsStr, L"DEFAULT") == 0) ? 8 : Strtoi (DataBitsStr));\r
  switch (*ParityStr) {\r
    case L'D':\r
      Uart->Parity = 0;\r
      break;\r
\r
    case L'N':\r
      Uart->Parity = 1;\r
      break;\r
\r
    case L'E':\r
      Uart->Parity = 2;\r
      break;\r
\r
    case L'O':\r
      Uart->Parity = 3;\r
      break;\r
\r
    case L'M':\r
      Uart->Parity = 4;\r
      break;\r
\r
    case L'S':\r
      Uart->Parity = 5;\r
      break;\r
\r
    default:\r
      Uart->Parity = (UINT8)Strtoi (ParityStr);\r
      break;\r
  }\r
\r
  if (StrCmp (StopBitsStr, L"D") == 0) {\r
    Uart->StopBits = (UINT8)0;\r
  } else if (StrCmp (StopBitsStr, L"1") == 0) {\r
    Uart->StopBits = (UINT8)1;\r
  } else if (StrCmp (StopBitsStr, L"1.5") == 0) {\r
    Uart->StopBits = (UINT8)2;\r
  } else if (StrCmp (StopBitsStr, L"2") == 0) {\r
    Uart->StopBits = (UINT8)3;\r
  } else {\r
    Uart->StopBits = (UINT8)Strtoi (StopBitsStr);\r
  }\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Uart;\r
}\r
\r
/**\r
  Converts a text device path node to USB class device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
  @param UsbClassText    A pointer to USB_CLASS_TEXT structure to be integrated to USB Class Text.\r
\r
  @return A pointer to the newly-created USB class device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
ConvertFromTextUsbClass (\r
  IN CHAR16          *TextDeviceNode,\r
  IN USB_CLASS_TEXT  *UsbClassText\r
  )\r
{\r
  CHAR16                 *VIDStr;\r
  CHAR16                 *PIDStr;\r
  CHAR16                 *ClassStr;\r
  CHAR16                 *SubClassStr;\r
  CHAR16                 *ProtocolStr;\r
  USB_CLASS_DEVICE_PATH  *UsbClass;\r
\r
  UsbClass = (USB_CLASS_DEVICE_PATH *)CreateDeviceNode (\r
                                        MESSAGING_DEVICE_PATH,\r
                                        MSG_USB_CLASS_DP,\r
                                        (UINT16)sizeof (USB_CLASS_DEVICE_PATH)\r
                                        );\r
\r
  VIDStr = GetNextParamStr (&TextDeviceNode);\r
  PIDStr = GetNextParamStr (&TextDeviceNode);\r
  if (UsbClassText->ClassExist) {\r
    ClassStr = GetNextParamStr (&TextDeviceNode);\r
    if (*ClassStr == L'\0') {\r
      UsbClass->DeviceClass = 0xFF;\r
    } else {\r
      UsbClass->DeviceClass = (UINT8)Strtoi (ClassStr);\r
    }\r
  } else {\r
    UsbClass->DeviceClass = UsbClassText->Class;\r
  }\r
\r
  if (UsbClassText->SubClassExist) {\r
    SubClassStr = GetNextParamStr (&TextDeviceNode);\r
    if (*SubClassStr == L'\0') {\r
      UsbClass->DeviceSubClass = 0xFF;\r
    } else {\r
      UsbClass->DeviceSubClass = (UINT8)Strtoi (SubClassStr);\r
    }\r
  } else {\r
    UsbClass->DeviceSubClass = UsbClassText->SubClass;\r
  }\r
\r
  ProtocolStr = GetNextParamStr (&TextDeviceNode);\r
\r
  if (*VIDStr == L'\0') {\r
    UsbClass->VendorId = 0xFFFF;\r
  } else {\r
    UsbClass->VendorId = (UINT16)Strtoi (VIDStr);\r
  }\r
\r
  if (*PIDStr == L'\0') {\r
    UsbClass->ProductId = 0xFFFF;\r
  } else {\r
    UsbClass->ProductId = (UINT16)Strtoi (PIDStr);\r
  }\r
\r
  if (*ProtocolStr == L'\0') {\r
    UsbClass->DeviceProtocol = 0xFF;\r
  } else {\r
    UsbClass->DeviceProtocol = (UINT8)Strtoi (ProtocolStr);\r
  }\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)UsbClass;\r
}\r
\r
/**\r
  Converts a text device path node to USB class device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created USB class device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextUsbClass (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  USB_CLASS_TEXT  UsbClassText;\r
\r
  UsbClassText.ClassExist    = TRUE;\r
  UsbClassText.SubClassExist = TRUE;\r
\r
  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);\r
}\r
\r
/**\r
  Converts a text device path node to USB audio device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created USB audio device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextUsbAudio (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  USB_CLASS_TEXT  UsbClassText;\r
\r
  UsbClassText.ClassExist    = FALSE;\r
  UsbClassText.Class         = USB_CLASS_AUDIO;\r
  UsbClassText.SubClassExist = TRUE;\r
\r
  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);\r
}\r
\r
/**\r
  Converts a text device path node to USB CDC Control device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created USB CDC Control device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextUsbCDCControl (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  USB_CLASS_TEXT  UsbClassText;\r
\r
  UsbClassText.ClassExist    = FALSE;\r
  UsbClassText.Class         = USB_CLASS_CDCCONTROL;\r
  UsbClassText.SubClassExist = TRUE;\r
\r
  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);\r
}\r
\r
/**\r
  Converts a text device path node to USB HID device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created USB HID device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextUsbHID (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  USB_CLASS_TEXT  UsbClassText;\r
\r
  UsbClassText.ClassExist    = FALSE;\r
  UsbClassText.Class         = USB_CLASS_HID;\r
  UsbClassText.SubClassExist = TRUE;\r
\r
  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);\r
}\r
\r
/**\r
  Converts a text device path node to USB Image device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created USB Image device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextUsbImage (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  USB_CLASS_TEXT  UsbClassText;\r
\r
  UsbClassText.ClassExist    = FALSE;\r
  UsbClassText.Class         = USB_CLASS_IMAGE;\r
  UsbClassText.SubClassExist = TRUE;\r
\r
  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);\r
}\r
\r
/**\r
  Converts a text device path node to USB Print device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created USB Print device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextUsbPrinter (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  USB_CLASS_TEXT  UsbClassText;\r
\r
  UsbClassText.ClassExist    = FALSE;\r
  UsbClassText.Class         = USB_CLASS_PRINTER;\r
  UsbClassText.SubClassExist = TRUE;\r
\r
  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);\r
}\r
\r
/**\r
  Converts a text device path node to USB mass storage device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created USB mass storage device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextUsbMassStorage (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  USB_CLASS_TEXT  UsbClassText;\r
\r
  UsbClassText.ClassExist    = FALSE;\r
  UsbClassText.Class         = USB_CLASS_MASS_STORAGE;\r
  UsbClassText.SubClassExist = TRUE;\r
\r
  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);\r
}\r
\r
/**\r
  Converts a text device path node to USB HUB device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created USB HUB device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextUsbHub (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  USB_CLASS_TEXT  UsbClassText;\r
\r
  UsbClassText.ClassExist    = FALSE;\r
  UsbClassText.Class         = USB_CLASS_HUB;\r
  UsbClassText.SubClassExist = TRUE;\r
\r
  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);\r
}\r
\r
/**\r
  Converts a text device path node to USB CDC data device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created USB CDC data device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextUsbCDCData (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  USB_CLASS_TEXT  UsbClassText;\r
\r
  UsbClassText.ClassExist    = FALSE;\r
  UsbClassText.Class         = USB_CLASS_CDCDATA;\r
  UsbClassText.SubClassExist = TRUE;\r
\r
  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);\r
}\r
\r
/**\r
  Converts a text device path node to USB smart card device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created USB smart card device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextUsbSmartCard (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  USB_CLASS_TEXT  UsbClassText;\r
\r
  UsbClassText.ClassExist    = FALSE;\r
  UsbClassText.Class         = USB_CLASS_SMART_CARD;\r
  UsbClassText.SubClassExist = TRUE;\r
\r
  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);\r
}\r
\r
/**\r
  Converts a text device path node to USB video device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created USB video device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextUsbVideo (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  USB_CLASS_TEXT  UsbClassText;\r
\r
  UsbClassText.ClassExist    = FALSE;\r
  UsbClassText.Class         = USB_CLASS_VIDEO;\r
  UsbClassText.SubClassExist = TRUE;\r
\r
  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);\r
}\r
\r
/**\r
  Converts a text device path node to USB diagnostic device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created USB diagnostic device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextUsbDiagnostic (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  USB_CLASS_TEXT  UsbClassText;\r
\r
  UsbClassText.ClassExist    = FALSE;\r
  UsbClassText.Class         = USB_CLASS_DIAGNOSTIC;\r
  UsbClassText.SubClassExist = TRUE;\r
\r
  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);\r
}\r
\r
/**\r
  Converts a text device path node to USB wireless device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created USB wireless device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextUsbWireless (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  USB_CLASS_TEXT  UsbClassText;\r
\r
  UsbClassText.ClassExist    = FALSE;\r
  UsbClassText.Class         = USB_CLASS_WIRELESS;\r
  UsbClassText.SubClassExist = TRUE;\r
\r
  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);\r
}\r
\r
/**\r
  Converts a text device path node to USB device firmware update device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created USB device firmware update device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextUsbDeviceFirmwareUpdate (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  USB_CLASS_TEXT  UsbClassText;\r
\r
  UsbClassText.ClassExist    = FALSE;\r
  UsbClassText.Class         = USB_CLASS_RESERVE;\r
  UsbClassText.SubClassExist = FALSE;\r
  UsbClassText.SubClass      = USB_SUBCLASS_FW_UPDATE;\r
\r
  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);\r
}\r
\r
/**\r
  Converts a text device path node to USB IRDA bridge device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created USB IRDA bridge device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextUsbIrdaBridge (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  USB_CLASS_TEXT  UsbClassText;\r
\r
  UsbClassText.ClassExist    = FALSE;\r
  UsbClassText.Class         = USB_CLASS_RESERVE;\r
  UsbClassText.SubClassExist = FALSE;\r
  UsbClassText.SubClass      = USB_SUBCLASS_IRDA_BRIDGE;\r
\r
  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);\r
}\r
\r
/**\r
  Converts a text device path node to USB text and measurement device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created USB text and measurement device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextUsbTestAndMeasurement (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  USB_CLASS_TEXT  UsbClassText;\r
\r
  UsbClassText.ClassExist    = FALSE;\r
  UsbClassText.Class         = USB_CLASS_RESERVE;\r
  UsbClassText.SubClassExist = FALSE;\r
  UsbClassText.SubClass      = USB_SUBCLASS_TEST;\r
\r
  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);\r
}\r
\r
/**\r
  Converts a text device path node to USB WWID device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created USB WWID device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextUsbWwid (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16                *VIDStr;\r
  CHAR16                *PIDStr;\r
  CHAR16                *InterfaceNumStr;\r
  CHAR16                *SerialNumberStr;\r
  USB_WWID_DEVICE_PATH  *UsbWwid;\r
  UINTN                 SerialNumberStrLen;\r
\r
  VIDStr             = GetNextParamStr (&TextDeviceNode);\r
  PIDStr             = GetNextParamStr (&TextDeviceNode);\r
  InterfaceNumStr    = GetNextParamStr (&TextDeviceNode);\r
  SerialNumberStr    = GetNextParamStr (&TextDeviceNode);\r
  SerialNumberStrLen = StrLen (SerialNumberStr);\r
  if ((SerialNumberStrLen >= 2) &&\r
      (SerialNumberStr[0] == L'\"') &&\r
      (SerialNumberStr[SerialNumberStrLen - 1] == L'\"')\r
      )\r
  {\r
    SerialNumberStr[SerialNumberStrLen - 1] = L'\0';\r
    SerialNumberStr++;\r
    SerialNumberStrLen -= 2;\r
  }\r
\r
  UsbWwid = (USB_WWID_DEVICE_PATH *)CreateDeviceNode (\r
                                      MESSAGING_DEVICE_PATH,\r
                                      MSG_USB_WWID_DP,\r
                                      (UINT16)(sizeof (USB_WWID_DEVICE_PATH) + SerialNumberStrLen * sizeof (CHAR16))\r
                                      );\r
  UsbWwid->VendorId        = (UINT16)Strtoi (VIDStr);\r
  UsbWwid->ProductId       = (UINT16)Strtoi (PIDStr);\r
  UsbWwid->InterfaceNumber = (UINT16)Strtoi (InterfaceNumStr);\r
\r
  //\r
  // There is no memory allocated in UsbWwid for the '\0' in SerialNumberStr.\r
  // Therefore, the '\0' will not be copied.\r
  //\r
  CopyMem (\r
    (UINT8 *)UsbWwid + sizeof (USB_WWID_DEVICE_PATH),\r
    SerialNumberStr,\r
    SerialNumberStrLen * sizeof (CHAR16)\r
    );\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)UsbWwid;\r
}\r
\r
/**\r
  Converts a text device path node to Logic Unit device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created Logic Unit device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextUnit (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16                           *LunStr;\r
  DEVICE_LOGICAL_UNIT_DEVICE_PATH  *LogicalUnit;\r
\r
  LunStr      = GetNextParamStr (&TextDeviceNode);\r
  LogicalUnit = (DEVICE_LOGICAL_UNIT_DEVICE_PATH *)CreateDeviceNode (\r
                                                     MESSAGING_DEVICE_PATH,\r
                                                     MSG_DEVICE_LOGICAL_UNIT_DP,\r
                                                     (UINT16)sizeof (DEVICE_LOGICAL_UNIT_DEVICE_PATH)\r
                                                     );\r
\r
  LogicalUnit->Lun = (UINT8)Strtoi (LunStr);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)LogicalUnit;\r
}\r
\r
/**\r
  Converts a text device path node to iSCSI device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created iSCSI device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextiSCSI (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  UINT16                       Options;\r
  CHAR16                       *NameStr;\r
  CHAR16                       *PortalGroupStr;\r
  CHAR16                       *LunStr;\r
  CHAR16                       *HeaderDigestStr;\r
  CHAR16                       *DataDigestStr;\r
  CHAR16                       *AuthenticationStr;\r
  CHAR16                       *ProtocolStr;\r
  CHAR8                        *AsciiStr;\r
  ISCSI_DEVICE_PATH_WITH_NAME  *ISCSIDevPath;\r
  UINT64                       Lun;\r
\r
  NameStr           = GetNextParamStr (&TextDeviceNode);\r
  PortalGroupStr    = GetNextParamStr (&TextDeviceNode);\r
  LunStr            = GetNextParamStr (&TextDeviceNode);\r
  HeaderDigestStr   = GetNextParamStr (&TextDeviceNode);\r
  DataDigestStr     = GetNextParamStr (&TextDeviceNode);\r
  AuthenticationStr = GetNextParamStr (&TextDeviceNode);\r
  ProtocolStr       = GetNextParamStr (&TextDeviceNode);\r
  ISCSIDevPath      = (ISCSI_DEVICE_PATH_WITH_NAME *)CreateDeviceNode (\r
                                                       MESSAGING_DEVICE_PATH,\r
                                                       MSG_ISCSI_DP,\r
                                                       (UINT16)(sizeof (ISCSI_DEVICE_PATH_WITH_NAME) + StrLen (NameStr))\r
                                                       );\r
\r
  AsciiStr = ISCSIDevPath->TargetName;\r
  StrToAscii (NameStr, &AsciiStr);\r
\r
  ISCSIDevPath->TargetPortalGroupTag = (UINT16)Strtoi (PortalGroupStr);\r
  Strtoi64 (LunStr, &Lun);\r
  WriteUnaligned64 ((UINT64 *)&ISCSIDevPath->Lun, SwapBytes64 (Lun));\r
\r
  Options = 0x0000;\r
  if (StrCmp (HeaderDigestStr, L"CRC32C") == 0) {\r
    Options |= 0x0002;\r
  }\r
\r
  if (StrCmp (DataDigestStr, L"CRC32C") == 0) {\r
    Options |= 0x0008;\r
  }\r
\r
  if (StrCmp (AuthenticationStr, L"None") == 0) {\r
    Options |= 0x0800;\r
  }\r
\r
  if (StrCmp (AuthenticationStr, L"CHAP_UNI") == 0) {\r
    Options |= 0x1000;\r
  }\r
\r
  ISCSIDevPath->LoginOption = (UINT16)Options;\r
\r
  if (IS_NULL (*ProtocolStr) || (StrCmp (ProtocolStr, L"TCP") == 0)) {\r
    ISCSIDevPath->NetworkProtocol = 0;\r
  } else {\r
    //\r
    // Undefined and reserved.\r
    //\r
    ISCSIDevPath->NetworkProtocol = 1;\r
  }\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)ISCSIDevPath;\r
}\r
\r
/**\r
  Converts a text device path node to VLAN device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created VLAN device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextVlan (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16            *VlanStr;\r
  VLAN_DEVICE_PATH  *Vlan;\r
\r
  VlanStr = GetNextParamStr (&TextDeviceNode);\r
  Vlan    = (VLAN_DEVICE_PATH *)CreateDeviceNode (\r
                                  MESSAGING_DEVICE_PATH,\r
                                  MSG_VLAN_DP,\r
                                  (UINT16)sizeof (VLAN_DEVICE_PATH)\r
                                  );\r
\r
  Vlan->VlanId = (UINT16)Strtoi (VlanStr);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Vlan;\r
}\r
\r
/**\r
  Converts a text device path node to Bluetooth device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created Bluetooth device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextBluetooth (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16                 *BluetoothStr;\r
  BLUETOOTH_DEVICE_PATH  *BluetoothDp;\r
\r
  BluetoothStr = GetNextParamStr (&TextDeviceNode);\r
  BluetoothDp  = (BLUETOOTH_DEVICE_PATH *)CreateDeviceNode (\r
                                            MESSAGING_DEVICE_PATH,\r
                                            MSG_BLUETOOTH_DP,\r
                                            (UINT16)sizeof (BLUETOOTH_DEVICE_PATH)\r
                                            );\r
  StrHexToBytes (\r
    BluetoothStr,\r
    sizeof (BLUETOOTH_ADDRESS) * 2,\r
    BluetoothDp->BD_ADDR.Address,\r
    sizeof (BLUETOOTH_ADDRESS)\r
    );\r
  return (EFI_DEVICE_PATH_PROTOCOL *)BluetoothDp;\r
}\r
\r
/**\r
  Converts a text device path node to Wi-Fi device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created Wi-Fi device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextWiFi (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16            *SSIdStr;\r
  CHAR8             AsciiStr[33];\r
  UINTN             DataLen;\r
  WIFI_DEVICE_PATH  *WiFiDp;\r
\r
  SSIdStr = GetNextParamStr (&TextDeviceNode);\r
  WiFiDp  = (WIFI_DEVICE_PATH *)CreateDeviceNode (\r
                                  MESSAGING_DEVICE_PATH,\r
                                  MSG_WIFI_DP,\r
                                  (UINT16)sizeof (WIFI_DEVICE_PATH)\r
                                  );\r
\r
  if (NULL != SSIdStr) {\r
    DataLen = StrLen (SSIdStr);\r
    if (StrLen (SSIdStr) > 32) {\r
      SSIdStr[32] = L'\0';\r
      DataLen     = 32;\r
    }\r
\r
    UnicodeStrToAsciiStrS (SSIdStr, AsciiStr, sizeof (AsciiStr));\r
    CopyMem (WiFiDp->SSId, AsciiStr, DataLen);\r
  }\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)WiFiDp;\r
}\r
\r
/**\r
  Converts a text device path node to Bluetooth LE device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created Bluetooth LE device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextBluetoothLE (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16                    *BluetoothLeAddrStr;\r
  CHAR16                    *BluetoothLeAddrTypeStr;\r
  BLUETOOTH_LE_DEVICE_PATH  *BluetoothLeDp;\r
\r
  BluetoothLeAddrStr     = GetNextParamStr (&TextDeviceNode);\r
  BluetoothLeAddrTypeStr = GetNextParamStr (&TextDeviceNode);\r
  BluetoothLeDp          = (BLUETOOTH_LE_DEVICE_PATH *)CreateDeviceNode (\r
                                                         MESSAGING_DEVICE_PATH,\r
                                                         MSG_BLUETOOTH_LE_DP,\r
                                                         (UINT16)sizeof (BLUETOOTH_LE_DEVICE_PATH)\r
                                                         );\r
\r
  BluetoothLeDp->Address.Type = (UINT8)Strtoi (BluetoothLeAddrTypeStr);\r
  StrHexToBytes (\r
    BluetoothLeAddrStr,\r
    sizeof (BluetoothLeDp->Address.Address) * 2,\r
    BluetoothLeDp->Address.Address,\r
    sizeof (BluetoothLeDp->Address.Address)\r
    );\r
  return (EFI_DEVICE_PATH_PROTOCOL *)BluetoothLeDp;\r
}\r
\r
/**\r
  Converts a text device path node to DNS device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created DNS device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextDns (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16           *DeviceNodeStr;\r
  CHAR16           *DeviceNodeStrPtr;\r
  UINT32           DnsServerIpCount;\r
  UINT16           DnsDeviceNodeLength;\r
  DNS_DEVICE_PATH  *DnsDeviceNode;\r
  UINT32           DnsServerIpIndex;\r
  CHAR16           *DnsServerIp;\r
\r
  //\r
  // Count the DNS server address number.\r
  //\r
  DeviceNodeStr = UefiDevicePathLibStrDuplicate (TextDeviceNode);\r
  if (DeviceNodeStr == NULL) {\r
    return NULL;\r
  }\r
\r
  DeviceNodeStrPtr = DeviceNodeStr;\r
\r
  DnsServerIpCount = 0;\r
  while (DeviceNodeStrPtr != NULL && *DeviceNodeStrPtr != L'\0') {\r
    GetNextParamStr (&DeviceNodeStrPtr);\r
    DnsServerIpCount++;\r
  }\r
\r
  FreePool (DeviceNodeStr);\r
  DeviceNodeStr = NULL;\r
\r
  //\r
  // One or more instances of the DNS server address in EFI_IP_ADDRESS,\r
  // otherwise, NULL will be returned.\r
  //\r
  if (DnsServerIpCount == 0) {\r
    return NULL;\r
  }\r
\r
  //\r
  // Create the DNS DeviceNode.\r
  //\r
  DnsDeviceNodeLength = (UINT16)(sizeof (EFI_DEVICE_PATH_PROTOCOL) + sizeof (UINT8) + DnsServerIpCount * sizeof (EFI_IP_ADDRESS));\r
  DnsDeviceNode       = (DNS_DEVICE_PATH *)CreateDeviceNode (\r
                                             MESSAGING_DEVICE_PATH,\r
                                             MSG_DNS_DP,\r
                                             DnsDeviceNodeLength\r
                                             );\r
  if (DnsDeviceNode == NULL) {\r
    return NULL;\r
  }\r
\r
  //\r
  // Confirm the DNS server address is IPv4 or IPv6 type.\r
  //\r
  DeviceNodeStrPtr = TextDeviceNode;\r
  while (!IS_NULL (*DeviceNodeStrPtr)) {\r
    if (*DeviceNodeStrPtr == L'.') {\r
      DnsDeviceNode->IsIPv6 = 0x00;\r
      break;\r
    }\r
\r
    if (*DeviceNodeStrPtr == L':') {\r
      DnsDeviceNode->IsIPv6 = 0x01;\r
      break;\r
    }\r
\r
    DeviceNodeStrPtr++;\r
  }\r
\r
  for (DnsServerIpIndex = 0; DnsServerIpIndex < DnsServerIpCount; DnsServerIpIndex++) {\r
    DnsServerIp = GetNextParamStr (&TextDeviceNode);\r
    if (DnsDeviceNode->IsIPv6 == 0x00) {\r
      StrToIpv4Address (DnsServerIp, NULL, &(DnsDeviceNode->DnsServerIp[DnsServerIpIndex].v4), NULL);\r
    } else {\r
      StrToIpv6Address (DnsServerIp, NULL, &(DnsDeviceNode->DnsServerIp[DnsServerIpIndex].v6), NULL);\r
    }\r
  }\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)DnsDeviceNode;\r
}\r
\r
/**\r
  Converts a text device path node to URI device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created URI device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextUri (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16           *UriStr;\r
  UINTN            UriLength;\r
  URI_DEVICE_PATH  *Uri;\r
\r
  UriStr    = GetNextParamStr (&TextDeviceNode);\r
  UriLength = StrnLenS (UriStr, MAX_UINT16 - sizeof (URI_DEVICE_PATH));\r
  Uri       = (URI_DEVICE_PATH *)CreateDeviceNode (\r
                                   MESSAGING_DEVICE_PATH,\r
                                   MSG_URI_DP,\r
                                   (UINT16)(sizeof (URI_DEVICE_PATH) + UriLength)\r
                                   );\r
\r
  while (UriLength-- != 0) {\r
    Uri->Uri[UriLength] = (CHAR8)UriStr[UriLength];\r
  }\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Uri;\r
}\r
\r
/**\r
  Converts a media text device path node to media device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to media device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextMediaPath (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  return DevPathFromTextGenericPath (MEDIA_DEVICE_PATH, TextDeviceNode);\r
}\r
\r
/**\r
  Converts a text device path node to HD device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created HD device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextHD (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16                 *PartitionStr;\r
  CHAR16                 *TypeStr;\r
  CHAR16                 *SignatureStr;\r
  CHAR16                 *StartStr;\r
  CHAR16                 *SizeStr;\r
  UINT32                 Signature32;\r
  HARDDRIVE_DEVICE_PATH  *Hd;\r
\r
  PartitionStr = GetNextParamStr (&TextDeviceNode);\r
  TypeStr      = GetNextParamStr (&TextDeviceNode);\r
  SignatureStr = GetNextParamStr (&TextDeviceNode);\r
  StartStr     = GetNextParamStr (&TextDeviceNode);\r
  SizeStr      = GetNextParamStr (&TextDeviceNode);\r
  Hd           = (HARDDRIVE_DEVICE_PATH *)CreateDeviceNode (\r
                                            MEDIA_DEVICE_PATH,\r
                                            MEDIA_HARDDRIVE_DP,\r
                                            (UINT16)sizeof (HARDDRIVE_DEVICE_PATH)\r
                                            );\r
\r
  Hd->PartitionNumber = (UINT32)Strtoi (PartitionStr);\r
\r
  ZeroMem (Hd->Signature, 16);\r
  Hd->MBRType = (UINT8)0;\r
\r
  if (StrCmp (TypeStr, L"MBR") == 0) {\r
    Hd->SignatureType = SIGNATURE_TYPE_MBR;\r
    Hd->MBRType       = 0x01;\r
\r
    Signature32 = (UINT32)Strtoi (SignatureStr);\r
    CopyMem (Hd->Signature, &Signature32, sizeof (UINT32));\r
  } else if (StrCmp (TypeStr, L"GPT") == 0) {\r
    Hd->SignatureType = SIGNATURE_TYPE_GUID;\r
    Hd->MBRType       = 0x02;\r
\r
    StrToGuid (SignatureStr, (EFI_GUID *)Hd->Signature);\r
  } else {\r
    Hd->SignatureType = (UINT8)Strtoi (TypeStr);\r
  }\r
\r
  Strtoi64 (StartStr, &Hd->PartitionStart);\r
  Strtoi64 (SizeStr, &Hd->PartitionSize);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Hd;\r
}\r
\r
/**\r
  Converts a text device path node to CDROM device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created CDROM device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextCDROM (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16             *EntryStr;\r
  CHAR16             *StartStr;\r
  CHAR16             *SizeStr;\r
  CDROM_DEVICE_PATH  *CDROMDevPath;\r
\r
  EntryStr     = GetNextParamStr (&TextDeviceNode);\r
  StartStr     = GetNextParamStr (&TextDeviceNode);\r
  SizeStr      = GetNextParamStr (&TextDeviceNode);\r
  CDROMDevPath = (CDROM_DEVICE_PATH *)CreateDeviceNode (\r
                                        MEDIA_DEVICE_PATH,\r
                                        MEDIA_CDROM_DP,\r
                                        (UINT16)sizeof (CDROM_DEVICE_PATH)\r
                                        );\r
\r
  CDROMDevPath->BootEntry = (UINT32)Strtoi (EntryStr);\r
  Strtoi64 (StartStr, &CDROMDevPath->PartitionStart);\r
  Strtoi64 (SizeStr, &CDROMDevPath->PartitionSize);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)CDROMDevPath;\r
}\r
\r
/**\r
  Converts a text device path node to Vendor-defined media device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created Vendor-defined media device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextVenMedia (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  return ConvertFromTextVendor (\r
           TextDeviceNode,\r
           MEDIA_DEVICE_PATH,\r
           MEDIA_VENDOR_DP\r
           );\r
}\r
\r
/**\r
  Converts a text device path node to File device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created File device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextFilePath (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  FILEPATH_DEVICE_PATH  *File;\r
\r
  File = (FILEPATH_DEVICE_PATH *)CreateDeviceNode (\r
                                   MEDIA_DEVICE_PATH,\r
                                   MEDIA_FILEPATH_DP,\r
                                   (UINT16)(sizeof (FILEPATH_DEVICE_PATH) + StrLen (TextDeviceNode) * 2)\r
                                   );\r
\r
  StrCpyS (File->PathName, StrLen (TextDeviceNode) + 1, TextDeviceNode);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)File;\r
}\r
\r
/**\r
  Converts a text device path node to Media protocol device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created Media protocol device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextMedia (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16                      *GuidStr;\r
  MEDIA_PROTOCOL_DEVICE_PATH  *Media;\r
\r
  GuidStr = GetNextParamStr (&TextDeviceNode);\r
  Media   = (MEDIA_PROTOCOL_DEVICE_PATH *)CreateDeviceNode (\r
                                            MEDIA_DEVICE_PATH,\r
                                            MEDIA_PROTOCOL_DP,\r
                                            (UINT16)sizeof (MEDIA_PROTOCOL_DEVICE_PATH)\r
                                            );\r
\r
  StrToGuid (GuidStr, &Media->Protocol);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Media;\r
}\r
\r
/**\r
  Converts a text device path node to firmware volume device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created firmware volume device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextFv (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16                    *GuidStr;\r
  MEDIA_FW_VOL_DEVICE_PATH  *Fv;\r
\r
  GuidStr = GetNextParamStr (&TextDeviceNode);\r
  Fv      = (MEDIA_FW_VOL_DEVICE_PATH *)CreateDeviceNode (\r
                                          MEDIA_DEVICE_PATH,\r
                                          MEDIA_PIWG_FW_VOL_DP,\r
                                          (UINT16)sizeof (MEDIA_FW_VOL_DEVICE_PATH)\r
                                          );\r
\r
  StrToGuid (GuidStr, &Fv->FvName);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Fv;\r
}\r
\r
/**\r
  Converts a text device path node to firmware file device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created firmware file device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextFvFile (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16                             *GuidStr;\r
  MEDIA_FW_VOL_FILEPATH_DEVICE_PATH  *FvFile;\r
\r
  GuidStr = GetNextParamStr (&TextDeviceNode);\r
  FvFile  = (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *)CreateDeviceNode (\r
                                                   MEDIA_DEVICE_PATH,\r
                                                   MEDIA_PIWG_FW_FILE_DP,\r
                                                   (UINT16)sizeof (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH)\r
                                                   );\r
\r
  StrToGuid (GuidStr, &FvFile->FvFileName);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)FvFile;\r
}\r
\r
/**\r
  Converts a text device path node to text relative offset device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created Text device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextRelativeOffsetRange (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16                                   *StartingOffsetStr;\r
  CHAR16                                   *EndingOffsetStr;\r
  MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH  *Offset;\r
\r
  StartingOffsetStr = GetNextParamStr (&TextDeviceNode);\r
  EndingOffsetStr   = GetNextParamStr (&TextDeviceNode);\r
  Offset            = (MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH *)CreateDeviceNode (\r
                                                                   MEDIA_DEVICE_PATH,\r
                                                                   MEDIA_RELATIVE_OFFSET_RANGE_DP,\r
                                                                   (UINT16)sizeof (MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH)\r
                                                                   );\r
\r
  Strtoi64 (StartingOffsetStr, &Offset->StartingOffset);\r
  Strtoi64 (EndingOffsetStr, &Offset->EndingOffset);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Offset;\r
}\r
\r
/**\r
  Converts a text device path node to text ram disk device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created Text device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextRamDisk (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16                      *StartingAddrStr;\r
  CHAR16                      *EndingAddrStr;\r
  CHAR16                      *TypeGuidStr;\r
  CHAR16                      *InstanceStr;\r
  MEDIA_RAM_DISK_DEVICE_PATH  *RamDisk;\r
  UINT64                      StartingAddr;\r
  UINT64                      EndingAddr;\r
\r
  StartingAddrStr = GetNextParamStr (&TextDeviceNode);\r
  EndingAddrStr   = GetNextParamStr (&TextDeviceNode);\r
  InstanceStr     = GetNextParamStr (&TextDeviceNode);\r
  TypeGuidStr     = GetNextParamStr (&TextDeviceNode);\r
  RamDisk         = (MEDIA_RAM_DISK_DEVICE_PATH *)CreateDeviceNode (\r
                                                    MEDIA_DEVICE_PATH,\r
                                                    MEDIA_RAM_DISK_DP,\r
                                                    (UINT16)sizeof (MEDIA_RAM_DISK_DEVICE_PATH)\r
                                                    );\r
\r
  Strtoi64 (StartingAddrStr, &StartingAddr);\r
  WriteUnaligned64 ((UINT64 *)&(RamDisk->StartingAddr[0]), StartingAddr);\r
  Strtoi64 (EndingAddrStr, &EndingAddr);\r
  WriteUnaligned64 ((UINT64 *)&(RamDisk->EndingAddr[0]), EndingAddr);\r
  RamDisk->Instance = (UINT16)Strtoi (InstanceStr);\r
  StrToGuid (TypeGuidStr, &RamDisk->TypeGuid);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)RamDisk;\r
}\r
\r
/**\r
  Converts a text device path node to text virtual disk device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created Text device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextVirtualDisk (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16                      *StartingAddrStr;\r
  CHAR16                      *EndingAddrStr;\r
  CHAR16                      *InstanceStr;\r
  MEDIA_RAM_DISK_DEVICE_PATH  *RamDisk;\r
  UINT64                      StartingAddr;\r
  UINT64                      EndingAddr;\r
\r
  StartingAddrStr = GetNextParamStr (&TextDeviceNode);\r
  EndingAddrStr   = GetNextParamStr (&TextDeviceNode);\r
  InstanceStr     = GetNextParamStr (&TextDeviceNode);\r
\r
  RamDisk = (MEDIA_RAM_DISK_DEVICE_PATH *)CreateDeviceNode (\r
                                            MEDIA_DEVICE_PATH,\r
                                            MEDIA_RAM_DISK_DP,\r
                                            (UINT16)sizeof (MEDIA_RAM_DISK_DEVICE_PATH)\r
                                            );\r
\r
  Strtoi64 (StartingAddrStr, &StartingAddr);\r
  WriteUnaligned64 ((UINT64 *)&(RamDisk->StartingAddr[0]), StartingAddr);\r
  Strtoi64 (EndingAddrStr, &EndingAddr);\r
  WriteUnaligned64 ((UINT64 *)&(RamDisk->EndingAddr[0]), EndingAddr);\r
  RamDisk->Instance = (UINT16)Strtoi (InstanceStr);\r
  CopyGuid (&RamDisk->TypeGuid, &gEfiVirtualDiskGuid);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)RamDisk;\r
}\r
\r
/**\r
  Converts a text device path node to text virtual cd device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created Text device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextVirtualCd (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16                      *StartingAddrStr;\r
  CHAR16                      *EndingAddrStr;\r
  CHAR16                      *InstanceStr;\r
  MEDIA_RAM_DISK_DEVICE_PATH  *RamDisk;\r
  UINT64                      StartingAddr;\r
  UINT64                      EndingAddr;\r
\r
  StartingAddrStr = GetNextParamStr (&TextDeviceNode);\r
  EndingAddrStr   = GetNextParamStr (&TextDeviceNode);\r
  InstanceStr     = GetNextParamStr (&TextDeviceNode);\r
\r
  RamDisk = (MEDIA_RAM_DISK_DEVICE_PATH *)CreateDeviceNode (\r
                                            MEDIA_DEVICE_PATH,\r
                                            MEDIA_RAM_DISK_DP,\r
                                            (UINT16)sizeof (MEDIA_RAM_DISK_DEVICE_PATH)\r
                                            );\r
\r
  Strtoi64 (StartingAddrStr, &StartingAddr);\r
  WriteUnaligned64 ((UINT64 *)&(RamDisk->StartingAddr[0]), StartingAddr);\r
  Strtoi64 (EndingAddrStr, &EndingAddr);\r
  WriteUnaligned64 ((UINT64 *)&(RamDisk->EndingAddr[0]), EndingAddr);\r
  RamDisk->Instance = (UINT16)Strtoi (InstanceStr);\r
  CopyGuid (&RamDisk->TypeGuid, &gEfiVirtualCdGuid);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)RamDisk;\r
}\r
\r
/**\r
  Converts a text device path node to text persistent virtual disk device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created Text device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextPersistentVirtualDisk (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16                      *StartingAddrStr;\r
  CHAR16                      *EndingAddrStr;\r
  CHAR16                      *InstanceStr;\r
  MEDIA_RAM_DISK_DEVICE_PATH  *RamDisk;\r
  UINT64                      StartingAddr;\r
  UINT64                      EndingAddr;\r
\r
  StartingAddrStr = GetNextParamStr (&TextDeviceNode);\r
  EndingAddrStr   = GetNextParamStr (&TextDeviceNode);\r
  InstanceStr     = GetNextParamStr (&TextDeviceNode);\r
\r
  RamDisk = (MEDIA_RAM_DISK_DEVICE_PATH *)CreateDeviceNode (\r
                                            MEDIA_DEVICE_PATH,\r
                                            MEDIA_RAM_DISK_DP,\r
                                            (UINT16)sizeof (MEDIA_RAM_DISK_DEVICE_PATH)\r
                                            );\r
\r
  Strtoi64 (StartingAddrStr, &StartingAddr);\r
  WriteUnaligned64 ((UINT64 *)&(RamDisk->StartingAddr[0]), StartingAddr);\r
  Strtoi64 (EndingAddrStr, &EndingAddr);\r
  WriteUnaligned64 ((UINT64 *)&(RamDisk->EndingAddr[0]), EndingAddr);\r
  RamDisk->Instance = (UINT16)Strtoi (InstanceStr);\r
  CopyGuid (&RamDisk->TypeGuid, &gEfiPersistentVirtualDiskGuid);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)RamDisk;\r
}\r
\r
/**\r
  Converts a text device path node to text persistent virtual cd device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created Text device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextPersistentVirtualCd (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16                      *StartingAddrStr;\r
  CHAR16                      *EndingAddrStr;\r
  CHAR16                      *InstanceStr;\r
  MEDIA_RAM_DISK_DEVICE_PATH  *RamDisk;\r
  UINT64                      StartingAddr;\r
  UINT64                      EndingAddr;\r
\r
  StartingAddrStr = GetNextParamStr (&TextDeviceNode);\r
  EndingAddrStr   = GetNextParamStr (&TextDeviceNode);\r
  InstanceStr     = GetNextParamStr (&TextDeviceNode);\r
\r
  RamDisk = (MEDIA_RAM_DISK_DEVICE_PATH *)CreateDeviceNode (\r
                                            MEDIA_DEVICE_PATH,\r
                                            MEDIA_RAM_DISK_DP,\r
                                            (UINT16)sizeof (MEDIA_RAM_DISK_DEVICE_PATH)\r
                                            );\r
\r
  Strtoi64 (StartingAddrStr, &StartingAddr);\r
  WriteUnaligned64 ((UINT64 *)&(RamDisk->StartingAddr[0]), StartingAddr);\r
  Strtoi64 (EndingAddrStr, &EndingAddr);\r
  WriteUnaligned64 ((UINT64 *)&(RamDisk->EndingAddr[0]), EndingAddr);\r
  RamDisk->Instance = (UINT16)Strtoi (InstanceStr);\r
  CopyGuid (&RamDisk->TypeGuid, &gEfiPersistentVirtualCdGuid);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)RamDisk;\r
}\r
\r
/**\r
  Converts a BBS text device path node to BBS device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to BBS device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextBbsPath (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  return DevPathFromTextGenericPath (BBS_DEVICE_PATH, TextDeviceNode);\r
}\r
\r
/**\r
  Converts a text device path node to BIOS Boot Specification device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created BIOS Boot Specification device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextBBS (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  CHAR16               *TypeStr;\r
  CHAR16               *IdStr;\r
  CHAR16               *FlagsStr;\r
  CHAR8                *AsciiStr;\r
  BBS_BBS_DEVICE_PATH  *Bbs;\r
\r
  TypeStr  = GetNextParamStr (&TextDeviceNode);\r
  IdStr    = GetNextParamStr (&TextDeviceNode);\r
  FlagsStr = GetNextParamStr (&TextDeviceNode);\r
  Bbs      = (BBS_BBS_DEVICE_PATH *)CreateDeviceNode (\r
                                      BBS_DEVICE_PATH,\r
                                      BBS_BBS_DP,\r
                                      (UINT16)(sizeof (BBS_BBS_DEVICE_PATH) + StrLen (IdStr))\r
                                      );\r
\r
  if (StrCmp (TypeStr, L"Floppy") == 0) {\r
    Bbs->DeviceType = BBS_TYPE_FLOPPY;\r
  } else if (StrCmp (TypeStr, L"HD") == 0) {\r
    Bbs->DeviceType = BBS_TYPE_HARDDRIVE;\r
  } else if (StrCmp (TypeStr, L"CDROM") == 0) {\r
    Bbs->DeviceType = BBS_TYPE_CDROM;\r
  } else if (StrCmp (TypeStr, L"PCMCIA") == 0) {\r
    Bbs->DeviceType = BBS_TYPE_PCMCIA;\r
  } else if (StrCmp (TypeStr, L"USB") == 0) {\r
    Bbs->DeviceType = BBS_TYPE_USB;\r
  } else if (StrCmp (TypeStr, L"Network") == 0) {\r
    Bbs->DeviceType = BBS_TYPE_EMBEDDED_NETWORK;\r
  } else {\r
    Bbs->DeviceType = (UINT16)Strtoi (TypeStr);\r
  }\r
\r
  AsciiStr = Bbs->String;\r
  StrToAscii (IdStr, &AsciiStr);\r
\r
  Bbs->StatusFlag = (UINT16)Strtoi (FlagsStr);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Bbs;\r
}\r
\r
/**\r
  Converts a text device path node to SATA device path structure.\r
\r
  @param TextDeviceNode  The input Text device path node.\r
\r
  @return A pointer to the newly-created SATA device path structure.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
DevPathFromTextSata (\r
  IN CHAR16  *TextDeviceNode\r
  )\r
{\r
  SATA_DEVICE_PATH  *Sata;\r
  CHAR16            *Param1;\r
  CHAR16            *Param2;\r
  CHAR16            *Param3;\r
\r
  Param1 = GetNextParamStr (&TextDeviceNode);\r
  Param2 = GetNextParamStr (&TextDeviceNode);\r
  Param3 = GetNextParamStr (&TextDeviceNode);\r
\r
  Sata = (SATA_DEVICE_PATH *)CreateDeviceNode (\r
                               MESSAGING_DEVICE_PATH,\r
                               MSG_SATA_DP,\r
                               (UINT16)sizeof (SATA_DEVICE_PATH)\r
                               );\r
  Sata->HBAPortNumber = (UINT16)Strtoi (Param1);\r
\r
  //\r
  // According to UEFI spec, if PMPN is not provided, the default is 0xFFFF\r
  //\r
  if (*Param2 == L'\0' ) {\r
    Sata->PortMultiplierPortNumber = 0xFFFF;\r
  } else {\r
    Sata->PortMultiplierPortNumber = (UINT16)Strtoi (Param2);\r
  }\r
\r
  Sata->Lun = (UINT16)Strtoi (Param3);\r
\r
  return (EFI_DEVICE_PATH_PROTOCOL *)Sata;\r
}\r
\r
GLOBAL_REMOVE_IF_UNREFERENCED DEVICE_PATH_FROM_TEXT_TABLE  mUefiDevicePathLibDevPathFromTextTable[] = {\r
  { L"Path",                    DevPathFromTextPath                    },\r
\r
  { L"HardwarePath",            DevPathFromTextHardwarePath            },\r
  { L"Pci",                     DevPathFromTextPci                     },\r
  { L"PcCard",                  DevPathFromTextPcCard                  },\r
  { L"MemoryMapped",            DevPathFromTextMemoryMapped            },\r
  { L"VenHw",                   DevPathFromTextVenHw                   },\r
  { L"Ctrl",                    DevPathFromTextCtrl                    },\r
  { L"BMC",                     DevPathFromTextBmc                     },\r
\r
  { L"AcpiPath",                DevPathFromTextAcpiPath                },\r
  { L"Acpi",                    DevPathFromTextAcpi                    },\r
  { L"PciRoot",                 DevPathFromTextPciRoot                 },\r
  { L"PcieRoot",                DevPathFromTextPcieRoot                },\r
  { L"Floppy",                  DevPathFromTextFloppy                  },\r
  { L"Keyboard",                DevPathFromTextKeyboard                },\r
  { L"Serial",                  DevPathFromTextSerial                  },\r
  { L"ParallelPort",            DevPathFromTextParallelPort            },\r
  { L"AcpiEx",                  DevPathFromTextAcpiEx                  },\r
  { L"AcpiExp",                 DevPathFromTextAcpiExp                 },\r
  { L"AcpiAdr",                 DevPathFromTextAcpiAdr                 },\r
\r
  { L"Msg",                     DevPathFromTextMsg                     },\r
  { L"Ata",                     DevPathFromTextAta                     },\r
  { L"Scsi",                    DevPathFromTextScsi                    },\r
  { L"Fibre",                   DevPathFromTextFibre                   },\r
  { L"FibreEx",                 DevPathFromTextFibreEx                 },\r
  { L"I1394",                   DevPathFromText1394                    },\r
  { L"USB",                     DevPathFromTextUsb                     },\r
  { L"I2O",                     DevPathFromTextI2O                     },\r
  { L"Infiniband",              DevPathFromTextInfiniband              },\r
  { L"VenMsg",                  DevPathFromTextVenMsg                  },\r
  { L"VenPcAnsi",               DevPathFromTextVenPcAnsi               },\r
  { L"VenVt100",                DevPathFromTextVenVt100                },\r
  { L"VenVt100Plus",            DevPathFromTextVenVt100Plus            },\r
  { L"VenUtf8",                 DevPathFromTextVenUtf8                 },\r
  { L"UartFlowCtrl",            DevPathFromTextUartFlowCtrl            },\r
  { L"SAS",                     DevPathFromTextSAS                     },\r
  { L"SasEx",                   DevPathFromTextSasEx                   },\r
  { L"NVMe",                    DevPathFromTextNVMe                    },\r
  { L"UFS",                     DevPathFromTextUfs                     },\r
  { L"SD",                      DevPathFromTextSd                      },\r
  { L"eMMC",                    DevPathFromTextEmmc                    },\r
  { L"DebugPort",               DevPathFromTextDebugPort               },\r
  { L"MAC",                     DevPathFromTextMAC                     },\r
  { L"IPv4",                    DevPathFromTextIPv4                    },\r
  { L"IPv6",                    DevPathFromTextIPv6                    },\r
  { L"Uart",                    DevPathFromTextUart                    },\r
  { L"UsbClass",                DevPathFromTextUsbClass                },\r
  { L"UsbAudio",                DevPathFromTextUsbAudio                },\r
  { L"UsbCDCControl",           DevPathFromTextUsbCDCControl           },\r
  { L"UsbHID",                  DevPathFromTextUsbHID                  },\r
  { L"UsbImage",                DevPathFromTextUsbImage                },\r
  { L"UsbPrinter",              DevPathFromTextUsbPrinter              },\r
  { L"UsbMassStorage",          DevPathFromTextUsbMassStorage          },\r
  { L"UsbHub",                  DevPathFromTextUsbHub                  },\r
  { L"UsbCDCData",              DevPathFromTextUsbCDCData              },\r
  { L"UsbSmartCard",            DevPathFromTextUsbSmartCard            },\r
  { L"UsbVideo",                DevPathFromTextUsbVideo                },\r
  { L"UsbDiagnostic",           DevPathFromTextUsbDiagnostic           },\r
  { L"UsbWireless",             DevPathFromTextUsbWireless             },\r
  { L"UsbDeviceFirmwareUpdate", DevPathFromTextUsbDeviceFirmwareUpdate },\r
  { L"UsbIrdaBridge",           DevPathFromTextUsbIrdaBridge           },\r
  { L"UsbTestAndMeasurement",   DevPathFromTextUsbTestAndMeasurement   },\r
  { L"UsbWwid",                 DevPathFromTextUsbWwid                 },\r
  { L"Unit",                    DevPathFromTextUnit                    },\r
  { L"iSCSI",                   DevPathFromTextiSCSI                   },\r
  { L"Vlan",                    DevPathFromTextVlan                    },\r
  { L"Dns",                     DevPathFromTextDns                     },\r
  { L"Uri",                     DevPathFromTextUri                     },\r
  { L"Bluetooth",               DevPathFromTextBluetooth               },\r
  { L"Wi-Fi",                   DevPathFromTextWiFi                    },\r
  { L"BluetoothLE",             DevPathFromTextBluetoothLE             },\r
  { L"MediaPath",               DevPathFromTextMediaPath               },\r
  { L"HD",                      DevPathFromTextHD                      },\r
  { L"CDROM",                   DevPathFromTextCDROM                   },\r
  { L"VenMedia",                DevPathFromTextVenMedia                },\r
  { L"Media",                   DevPathFromTextMedia                   },\r
  { L"Fv",                      DevPathFromTextFv                      },\r
  { L"FvFile",                  DevPathFromTextFvFile                  },\r
  { L"Offset",                  DevPathFromTextRelativeOffsetRange     },\r
  { L"RamDisk",                 DevPathFromTextRamDisk                 },\r
  { L"VirtualDisk",             DevPathFromTextVirtualDisk             },\r
  { L"VirtualCD",               DevPathFromTextVirtualCd               },\r
  { L"PersistentVirtualDisk",   DevPathFromTextPersistentVirtualDisk   },\r
  { L"PersistentVirtualCD",     DevPathFromTextPersistentVirtualCd     },\r
\r
  { L"BbsPath",                 DevPathFromTextBbsPath                 },\r
  { L"BBS",                     DevPathFromTextBBS                     },\r
  { L"Sata",                    DevPathFromTextSata                    },\r
  { NULL,                       NULL                                   }\r
};\r
\r
/**\r
  Convert text to the binary representation of a device node.\r
\r
  @param TextDeviceNode  TextDeviceNode points to the text representation of a device\r
                         node. Conversion starts with the first character and continues\r
                         until the first non-device node character.\r
\r
  @return A pointer to the EFI device node or NULL if TextDeviceNode is NULL or there was\r
          insufficient memory or text unsupported.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
EFIAPI\r
UefiDevicePathLibConvertTextToDeviceNode (\r
  IN CONST CHAR16  *TextDeviceNode\r
  )\r
{\r
  DEVICE_PATH_FROM_TEXT     FromText;\r
  CHAR16                    *ParamStr;\r
  EFI_DEVICE_PATH_PROTOCOL  *DeviceNode;\r
  CHAR16                    *DeviceNodeStr;\r
  UINTN                     Index;\r
\r
  if ((TextDeviceNode == NULL) || (IS_NULL (*TextDeviceNode))) {\r
    return NULL;\r
  }\r
\r
  ParamStr      = NULL;\r
  FromText      = NULL;\r
  DeviceNodeStr = UefiDevicePathLibStrDuplicate (TextDeviceNode);\r
  ASSERT (DeviceNodeStr != NULL);\r
\r
  for (Index = 0; mUefiDevicePathLibDevPathFromTextTable[Index].Function != NULL; Index++) {\r
    ParamStr = GetParamByNodeName (DeviceNodeStr, mUefiDevicePathLibDevPathFromTextTable[Index].DevicePathNodeText);\r
    if (ParamStr != NULL) {\r
      FromText = mUefiDevicePathLibDevPathFromTextTable[Index].Function;\r
      break;\r
    }\r
  }\r
\r
  if (FromText == NULL) {\r
    //\r
    // A file path\r
    //\r
    FromText   = DevPathFromTextFilePath;\r
    DeviceNode = FromText (DeviceNodeStr);\r
  } else {\r
    DeviceNode = FromText (ParamStr);\r
    FreePool (ParamStr);\r
  }\r
\r
  FreePool (DeviceNodeStr);\r
\r
  return DeviceNode;\r
}\r
\r
/**\r
  Convert text to the binary representation of a device path.\r
\r
\r
  @param TextDevicePath  TextDevicePath points to the text representation of a device\r
                         path. Conversion starts with the first character and continues\r
                         until the first non-device node character.\r
\r
  @return A pointer to the allocated device path or NULL if TextDeviceNode is NULL or\r
          there was insufficient memory.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
EFIAPI\r
UefiDevicePathLibConvertTextToDevicePath (\r
  IN CONST CHAR16  *TextDevicePath\r
  )\r
{\r
  EFI_DEVICE_PATH_PROTOCOL  *DeviceNode;\r
  EFI_DEVICE_PATH_PROTOCOL  *NewDevicePath;\r
  CHAR16                    *DevicePathStr;\r
  CHAR16                    *Str;\r
  CHAR16                    *DeviceNodeStr;\r
  BOOLEAN                   IsInstanceEnd;\r
  EFI_DEVICE_PATH_PROTOCOL  *DevicePath;\r
\r
  if ((TextDevicePath == NULL) || (IS_NULL (*TextDevicePath))) {\r
    return NULL;\r
  }\r
\r
  DevicePath = (EFI_DEVICE_PATH_PROTOCOL *)AllocatePool (END_DEVICE_PATH_LENGTH);\r
  ASSERT (DevicePath != NULL);\r
  SetDevicePathEndNode (DevicePath);\r
\r
  DevicePathStr = UefiDevicePathLibStrDuplicate (TextDevicePath);\r
\r
  Str = DevicePathStr;\r
  while ((DeviceNodeStr = GetNextDeviceNodeStr (&Str, &IsInstanceEnd)) != NULL) {\r
    DeviceNode = UefiDevicePathLibConvertTextToDeviceNode (DeviceNodeStr);\r
\r
    NewDevicePath = AppendDevicePathNode (DevicePath, DeviceNode);\r
    FreePool (DevicePath);\r
    FreePool (DeviceNode);\r
    DevicePath = NewDevicePath;\r
\r
    if (IsInstanceEnd) {\r
      DeviceNode = (EFI_DEVICE_PATH_PROTOCOL *)AllocatePool (END_DEVICE_PATH_LENGTH);\r
      ASSERT (DeviceNode != NULL);\r
      SetDevicePathEndNode (DeviceNode);\r
      DeviceNode->SubType = END_INSTANCE_DEVICE_PATH_SUBTYPE;\r
\r
      NewDevicePath = AppendDevicePathNode (DevicePath, DeviceNode);\r
      FreePool (DevicePath);\r
      FreePool (DeviceNode);\r
      DevicePath = NewDevicePath;\r
    }\r
  }\r
\r
  FreePool (DevicePathStr);\r
  return DevicePath;\r
}\r