MdePkg: Handle USBxxx device path when optional para is not specified

[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
This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution.  The full text of the license may be found at\r
http://opensource.org/licenses/bsd-license.php\r
\r
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\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
    StrPointer++;\r
    ParameterLength++;\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
  // 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
    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
      break;\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
/**\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
  // 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
  *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
  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
  AcpiEx->CID = EisaIdFromText (CIDStr);\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
    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
  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
  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
  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
  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
  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
\r
  } else if ((StrCmp (SASSATAStr, L"SATA") == 0) || (StrCmp (SASSATAStr, L"SAS") == 0)) {\r
\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
    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
    Info |= (Uint16 << 6);\r
\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
\r
  } else if ((StrCmp (SASSATAStr, L"SATA") == 0) || (StrCmp (SASSATAStr, L"SAS") == 0)) {\r
\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
    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
    Info |= (Uint16 << 6);\r
\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
/**\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
/**\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
  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
  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
  if (*PIDStr == L'\0') {\r
    UsbClass->ProductId       = 0xFFFF;\r
  } else {\r
    UsbClass->ProductId       = (UINT16) Strtoi (PIDStr);\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
/**\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
    SerialNumberStr[SerialNumberStrLen - 1] = L'\0';\r
    SerialNumberStr++;\r
    SerialNumberStrLen -= 2;\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, sizeof (BluetoothLeDp->Address.Address) * 2,\r
    BluetoothLeDp->Address.Address, 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
  //\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
  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