2 DevicePathFromText protocol as defined in the UEFI 2.0 specification.
4 Copyright (c) 2006 - 2008, Intel Corporation. <BR>
5 All rights reserved. This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
15 #include "DevicePath.h"
38 Length
= StrLen ((CHAR16
*) Src
);
40 ReturnStr
= AllocateCopyPool ((Length
+ 1) * sizeof (CHAR16
), (VOID
*) Src
);
54 Get parameter in a pair of parentheses follow the given node name.
55 For example, given the "Pci(0,1)" and NodeName "Pci", it returns "0,1".
58 Str - Device Path Text
59 NodeName - Name of the node
62 Parameter text for the node
69 UINTN ParameterLength
;
72 // Check whether the node name matchs
74 NodeNameLength
= StrLen (NodeName
);
75 if (CompareMem (Str
, NodeName
, NodeNameLength
* sizeof (CHAR16
)) != 0) {
79 ParamStr
= Str
+ NodeNameLength
;
80 if (!IS_LEFT_PARENTH (*ParamStr
)) {
85 // Skip the found '(' and find first occurrence of ')'
89 StrPointer
= ParamStr
;
90 while (!IS_NULL (*StrPointer
)) {
91 if (IS_RIGHT_PARENTH (*StrPointer
)) {
97 if (IS_NULL (*StrPointer
)) {
104 ParamStr
= AllocateCopyPool ((ParameterLength
+ 1) * sizeof (CHAR16
), ParamStr
);
105 if (ParamStr
== NULL
) {
109 // Terminate the parameter string
111 ParamStr
[ParameterLength
] = L
'\0';
119 IN OUT CHAR16
**List
,
125 Get current sub-string from a string list, before return
126 the list header is moved to next sub-string. The sub-string is separated
127 by the specified character. For example, the separator is ',', the string
128 list is "2,0,3", it returns "2", the remain list move to "0,3"
131 List - A string list separated by the specified separator
132 Separator - The separator character
135 pointer - The current sub-string
145 if (IS_NULL (*Str
)) {
150 // Find first occurrence of the separator
152 while (!IS_NULL (*Str
)) {
153 if (*Str
== Separator
) {
159 if (*Str
== Separator
) {
161 // Find a sub-string, terminate it
168 // Move to next sub-string
182 // The separator is comma
184 return SplitStr (List
, L
',');
189 GetNextDeviceNodeStr (
190 IN OUT CHAR16
**DevicePath
,
191 OUT BOOLEAN
*IsInstanceEnd
196 Get one device node from entire device path text.
199 Str - The entire device path text string
200 IsInstanceEnd - This node is the end of a device path instance
203 a pointer - A device node text
204 NULL - No more device node available
210 UINTN ParenthesesStack
;
213 if (IS_NULL (*Str
)) {
218 // Skip the leading '/', '(', ')' and ','
220 while (!IS_NULL (*Str
)) {
221 if (!IS_SLASH (*Str
) &&
223 !IS_LEFT_PARENTH (*Str
) &&
224 !IS_RIGHT_PARENTH (*Str
)) {
233 // Scan for the separator of this device node, '/' or ','
235 ParenthesesStack
= 0;
236 while (!IS_NULL (*Str
)) {
237 if ((IS_COMMA (*Str
) || IS_SLASH (*Str
)) && (ParenthesesStack
== 0)) {
241 if (IS_LEFT_PARENTH (*Str
)) {
243 } else if (IS_RIGHT_PARENTH (*Str
)) {
250 if (ParenthesesStack
!= 0) {
252 // The '(' doesn't pair with ')', invalid device path text
257 if (IS_COMMA (*Str
)) {
258 *IsInstanceEnd
= TRUE
;
262 *IsInstanceEnd
= FALSE
;
263 if (!IS_NULL (*Str
)) {
283 Determines if a Unicode character is a hexadecimal digit.
284 The test is case insensitive.
287 Digit - Pointer to byte that receives the value of the hex character.
288 Char - Unicode character to test.
291 TRUE - If the character is a hexadecimal digit.
296 if ((Char
>= L
'0') && (Char
<= L
'9')) {
297 *Digit
= (UINT8
) (Char
- L
'0');
301 if ((Char
>= L
'A') && (Char
<= L
'F')) {
302 *Digit
= (UINT8
) (Char
- L
'A' + 0x0A);
306 if ((Char
>= L
'a') && (Char
<= L
'f')) {
307 *Digit
= (UINT8
) (Char
- L
'a' + 0x0A);
320 OUT UINTN
*ConvertedStrLen OPTIONAL
325 Converts Unicode string to binary buffer.
326 The conversion may be partial.
327 The first character in the string that is not hex digit stops the conversion.
328 At a minimum, any blob of data could be represented as a hex string.
331 Buf - Pointer to buffer that receives the data.
332 Len - Length in bytes of the buffer to hold converted data.
333 If routine return with EFI_SUCCESS, containing length of converted data.
334 If routine return with EFI_BUFFER_TOO_SMALL, containg length of buffer desired.
335 Str - String to be converted from.
336 ConvertedStrLen - Length of the Hex String consumed.
339 EFI_SUCCESS: Routine Success.
340 EFI_BUFFER_TOO_SMALL: The buffer is too small to hold converted data.
354 // Find out how many hex characters the string has.
356 for (Idx
= 0, HexCnt
= 0; IsHexDigit (&Digit
, Str
[Idx
]); Idx
++, HexCnt
++);
363 // Two Unicode characters make up 1 buffer byte. Round up.
365 BufferLength
= (HexCnt
+ 1) / 2;
368 // Test if buffer is passed enough.
370 if (BufferLength
> (*Len
)) {
372 return EFI_BUFFER_TOO_SMALL
;
377 for (Idx
= 0; Idx
< HexCnt
; Idx
++) {
379 IsHexDigit (&Digit
, Str
[HexCnt
- 1 - Idx
]);
382 // For odd charaters, write the lower nibble for each buffer byte,
383 // and for even characters, the upper nibble.
385 if ((Idx
& 1) == 0) {
390 Byte
= (UINT8
) (Byte
| Digit
<< 4);
396 if (ConvertedStrLen
!= NULL
) {
397 *ConvertedStrLen
= HexCnt
;
412 Skip the leading white space and '0x' or '0X' of a integer string
415 Str - The integer string
416 IsHex - 1: Hex string, 0: Decimal string
425 // skip preceeding white space
427 while (*Str
&& *Str
== ' ') {
431 // skip preceeding zeros
433 while (*Str
&& *Str
== '0') {
437 // skip preceeding character 'x' or 'X'
439 if (*Str
&& (*Str
== 'x' || *Str
== 'X')) {
456 Convert hex string to uint
469 ASSERT (Str
!= NULL
);
472 // convert hex digits
475 Length
= sizeof (UINTN
);
476 HexStringToBuf ((UINT8
*) &Rvalue
, &Length
, Str
, NULL
);
491 Convert hex string to 64 bit data.
504 Length
= sizeof (UINT64
);
505 HexStringToBuf ((UINT8
*) Data
, &Length
, Str
, NULL
);
517 Convert decimal string to uint
532 ASSERT (str
!= NULL
);
534 High
= (UINTN
) -1 / 10;
535 Low
= (UINTN
) -1 % 10;
537 // skip preceeding white space
539 while (*str
&& *str
== ' ') {
548 if (Char
>= '0' && Char
<= '9') {
549 if ((Rvalue
> High
|| Rvalue
== High
) && (Char
- '0' > (INTN
) Low
)) {
553 Rvalue
= (Rvalue
* 10) + Char
- '0';
574 Convert decimal string to uint
589 ASSERT (str
!= NULL
);
590 ASSERT (Data
!= NULL
);
593 // skip preceeding white space
595 while (*str
&& *str
== ' ') {
604 if (Char
>= '0' && Char
<= '9') {
605 High
= LShiftU64 (Rvalue
, 3);
606 Low
= LShiftU64 (Rvalue
, 1);
607 Rvalue
= High
+ Low
+ Char
- '0';
627 Convert integer string to uint.
631 Str - The integer string. If leading with "0x" or "0X", it's heximal.
639 Str
= TrimHexStr (Str
, &IsHex
);
658 Convert integer string to 64 bit data.
662 Str - The integer string. If leading with "0x" or "0X", it's heximal.
670 Str
= TrimHexStr (Str
, &IsHex
);
683 IN UINTN BufferLength
,
695 // Two hex char make up one byte
697 StrLength
= BufferLength
* sizeof (CHAR16
);
699 for(Index
= 0; Index
< StrLength
; Index
++, Str
++) {
701 IsHexDigit (&Digit
, *Str
);
704 // For odd charaters, write the upper nibble for each buffer byte,
705 // and for even characters, the lower nibble.
707 if ((Index
& 1) == 0) {
708 Byte
= (UINT8
) (Digit
<< 4);
710 Byte
= Buf
[Index
/ 2];
712 Byte
= (UINT8
) (Byte
| Digit
);
715 Buf
[Index
/ 2] = Byte
;
729 UINTN ConvertedStrLen
;
732 BufferLength
= sizeof (Guid
->Data1
);
733 Status
= HexStringToBuf ((UINT8
*) &Guid
->Data1
, &BufferLength
, Str
, &ConvertedStrLen
);
734 if (EFI_ERROR (Status
)) {
737 Str
+= ConvertedStrLen
;
738 if (IS_HYPHEN (*Str
)) {
741 return EFI_UNSUPPORTED
;
744 BufferLength
= sizeof (Guid
->Data2
);
745 Status
= HexStringToBuf ((UINT8
*) &Guid
->Data2
, &BufferLength
, Str
, &ConvertedStrLen
);
746 if (EFI_ERROR (Status
)) {
749 Str
+= ConvertedStrLen
;
750 if (IS_HYPHEN (*Str
)) {
753 return EFI_UNSUPPORTED
;
756 BufferLength
= sizeof (Guid
->Data3
);
757 Status
= HexStringToBuf ((UINT8
*) &Guid
->Data3
, &BufferLength
, Str
, &ConvertedStrLen
);
758 if (EFI_ERROR (Status
)) {
761 Str
+= ConvertedStrLen
;
762 if (IS_HYPHEN (*Str
)) {
765 return EFI_UNSUPPORTED
;
768 StrToBuf (&Guid
->Data4
[0], 2, Str
);
770 // Skip 2 byte hex chars
774 if (IS_HYPHEN (*Str
)) {
777 return EFI_UNSUPPORTED
;
779 StrToBuf (&Guid
->Data4
[2], 6, Str
);
788 OUT EFI_IPv4_ADDRESS
*IPv4Addr
793 for (Index
= 0; Index
< 4; Index
++) {
794 IPv4Addr
->Addr
[Index
] = (UINT8
) Dtoi (SplitStr (Str
, L
'.'));
802 OUT EFI_IPv6_ADDRESS
*IPv6Addr
808 for (Index
= 0; Index
< 8; Index
++) {
809 Data
= (UINT16
) Xtoi (SplitStr (Str
, L
':'));
810 IPv6Addr
->Addr
[Index
* 2] = (UINT8
) (Data
>> 8);
811 IPv6Addr
->Addr
[Index
* 2 + 1] = (UINT8
) (Data
& 0xff);
819 IN OUT CHAR8
**AsciiStr
825 while (!IS_NULL (*Str
)) {
826 *(Dest
++) = (CHAR8
) *(Str
++);
831 // Return the string next to it
833 *AsciiStr
= Dest
+ 1;
837 EFI_DEVICE_PATH_PROTOCOL
*
839 IN CHAR16
*TextDeviceNode
844 PCI_DEVICE_PATH
*Pci
;
846 DeviceStr
= GetNextParamStr (&TextDeviceNode
);
847 FunctionStr
= GetNextParamStr (&TextDeviceNode
);
848 Pci
= (PCI_DEVICE_PATH
*) CreateDeviceNode (
849 HARDWARE_DEVICE_PATH
,
851 sizeof (PCI_DEVICE_PATH
)
854 Pci
->Function
= (UINT8
) Strtoi (FunctionStr
);
855 Pci
->Device
= (UINT8
) Strtoi (DeviceStr
);
857 return (EFI_DEVICE_PATH_PROTOCOL
*) Pci
;
861 EFI_DEVICE_PATH_PROTOCOL
*
862 DevPathFromTextPcCard (
863 IN CHAR16
*TextDeviceNode
866 CHAR16
*FunctionNumberStr
;
867 PCCARD_DEVICE_PATH
*Pccard
;
869 FunctionNumberStr
= GetNextParamStr (&TextDeviceNode
);
870 Pccard
= (PCCARD_DEVICE_PATH
*) CreateDeviceNode (
871 HARDWARE_DEVICE_PATH
,
873 sizeof (PCCARD_DEVICE_PATH
)
876 Pccard
->FunctionNumber
= (UINT8
) Strtoi (FunctionNumberStr
);
878 return (EFI_DEVICE_PATH_PROTOCOL
*) Pccard
;
882 EFI_DEVICE_PATH_PROTOCOL
*
883 DevPathFromTextMemoryMapped (
884 IN CHAR16
*TextDeviceNode
887 CHAR16
*MemoryTypeStr
;
888 CHAR16
*StartingAddressStr
;
889 CHAR16
*EndingAddressStr
;
890 MEMMAP_DEVICE_PATH
*MemMap
;
892 MemoryTypeStr
= GetNextParamStr (&TextDeviceNode
);
893 StartingAddressStr
= GetNextParamStr (&TextDeviceNode
);
894 EndingAddressStr
= GetNextParamStr (&TextDeviceNode
);
895 MemMap
= (MEMMAP_DEVICE_PATH
*) CreateDeviceNode (
896 HARDWARE_DEVICE_PATH
,
898 sizeof (MEMMAP_DEVICE_PATH
)
901 MemMap
->MemoryType
= (UINT32
) Strtoi (MemoryTypeStr
);
902 Strtoi64 (StartingAddressStr
, &MemMap
->StartingAddress
);
903 Strtoi64 (EndingAddressStr
, &MemMap
->EndingAddress
);
905 return (EFI_DEVICE_PATH_PROTOCOL
*) MemMap
;
909 EFI_DEVICE_PATH_PROTOCOL
*
910 ConvertFromTextVendor (
911 IN CHAR16
*TextDeviceNode
,
919 VENDOR_DEVICE_PATH
*Vendor
;
921 GuidStr
= GetNextParamStr (&TextDeviceNode
);
923 DataStr
= GetNextParamStr (&TextDeviceNode
);
924 Length
= StrLen (DataStr
);
926 // Two hex characters make up 1 buffer byte
928 Length
= (Length
+ 1) / 2;
930 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
933 (UINT16
) (sizeof (VENDOR_DEVICE_PATH
) + Length
)
936 StrToGuid (GuidStr
, &Vendor
->Guid
);
937 StrToBuf (((UINT8
*) Vendor
) + sizeof (VENDOR_DEVICE_PATH
), Length
, DataStr
);
939 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
943 EFI_DEVICE_PATH_PROTOCOL
*
944 DevPathFromTextVenHw (
945 IN CHAR16
*TextDeviceNode
948 return ConvertFromTextVendor (
950 HARDWARE_DEVICE_PATH
,
956 EFI_DEVICE_PATH_PROTOCOL
*
957 DevPathFromTextCtrl (
958 IN CHAR16
*TextDeviceNode
961 CHAR16
*ControllerStr
;
962 CONTROLLER_DEVICE_PATH
*Controller
;
964 ControllerStr
= GetNextParamStr (&TextDeviceNode
);
965 Controller
= (CONTROLLER_DEVICE_PATH
*) CreateDeviceNode (
966 HARDWARE_DEVICE_PATH
,
968 sizeof (CONTROLLER_DEVICE_PATH
)
970 Controller
->ControllerNumber
= (UINT32
) Strtoi (ControllerStr
);
972 return (EFI_DEVICE_PATH_PROTOCOL
*) Controller
;
984 PnpId
= Xtoi (Text
+ 3);
985 *EisaId
= (((Text
[0] - '@') & 0x1f) << 10) +
986 (((Text
[1] - '@') & 0x1f) << 5) +
987 ((Text
[2] - '@') & 0x1f) +
988 (UINT32
) (PnpId
<< 16);
991 EFI_DEVICE_PATH_PROTOCOL
*
992 DevPathFromTextAcpi (
993 IN CHAR16
*TextDeviceNode
998 ACPI_HID_DEVICE_PATH
*Acpi
;
1000 HIDStr
= GetNextParamStr (&TextDeviceNode
);
1001 UIDStr
= GetNextParamStr (&TextDeviceNode
);
1002 Acpi
= (ACPI_HID_DEVICE_PATH
*) CreateDeviceNode (
1005 sizeof (ACPI_HID_DEVICE_PATH
)
1008 EisaIdFromText (HIDStr
, &Acpi
->HID
);
1009 Acpi
->UID
= (UINT32
) Strtoi (UIDStr
);
1011 return (EFI_DEVICE_PATH_PROTOCOL
*) Acpi
;
1015 EFI_DEVICE_PATH_PROTOCOL
*
1016 ConvertFromTextAcpi (
1017 IN CHAR16
*TextDeviceNode
,
1022 ACPI_HID_DEVICE_PATH
*Acpi
;
1024 UIDStr
= GetNextParamStr (&TextDeviceNode
);
1025 Acpi
= (ACPI_HID_DEVICE_PATH
*) CreateDeviceNode (
1028 sizeof (ACPI_HID_DEVICE_PATH
)
1031 Acpi
->HID
= EFI_PNP_ID (PnPId
);
1032 Acpi
->UID
= (UINT32
) Strtoi (UIDStr
);
1034 return (EFI_DEVICE_PATH_PROTOCOL
*) Acpi
;
1038 EFI_DEVICE_PATH_PROTOCOL
*
1039 DevPathFromTextPciRoot (
1040 IN CHAR16
*TextDeviceNode
1043 return ConvertFromTextAcpi (TextDeviceNode
, 0x0a03);
1047 EFI_DEVICE_PATH_PROTOCOL
*
1048 DevPathFromTextFloppy (
1049 IN CHAR16
*TextDeviceNode
1052 return ConvertFromTextAcpi (TextDeviceNode
, 0x0604);
1056 EFI_DEVICE_PATH_PROTOCOL
*
1057 DevPathFromTextKeyboard (
1058 IN CHAR16
*TextDeviceNode
1061 return ConvertFromTextAcpi (TextDeviceNode
, 0x0301);
1065 EFI_DEVICE_PATH_PROTOCOL
*
1066 DevPathFromTextSerial (
1067 IN CHAR16
*TextDeviceNode
1070 return ConvertFromTextAcpi (TextDeviceNode
, 0x0501);
1074 EFI_DEVICE_PATH_PROTOCOL
*
1075 DevPathFromTextParallelPort (
1076 IN CHAR16
*TextDeviceNode
1079 return ConvertFromTextAcpi (TextDeviceNode
, 0x0401);
1083 EFI_DEVICE_PATH_PROTOCOL
*
1084 DevPathFromTextAcpiEx (
1085 IN CHAR16
*TextDeviceNode
1096 ACPI_EXTENDED_HID_DEVICE_PATH
*AcpiEx
;
1098 HIDStr
= GetNextParamStr (&TextDeviceNode
);
1099 CIDStr
= GetNextParamStr (&TextDeviceNode
);
1100 UIDStr
= GetNextParamStr (&TextDeviceNode
);
1101 HIDSTRStr
= GetNextParamStr (&TextDeviceNode
);
1102 CIDSTRStr
= GetNextParamStr (&TextDeviceNode
);
1103 UIDSTRStr
= GetNextParamStr (&TextDeviceNode
);
1105 Length
= (UINT16
) (sizeof (ACPI_EXTENDED_HID_DEVICE_PATH
) + StrLen (HIDSTRStr
) + 1);
1106 Length
= (UINT16
) (Length
+ StrLen (UIDSTRStr
) + 1);
1107 Length
= (UINT16
) (Length
+ StrLen (CIDSTRStr
) + 1);
1108 AcpiEx
= (ACPI_EXTENDED_HID_DEVICE_PATH
*) CreateDeviceNode (
1114 EisaIdFromText (HIDStr
, &AcpiEx
->HID
);
1115 EisaIdFromText (CIDStr
, &AcpiEx
->CID
);
1116 AcpiEx
->UID
= (UINT32
) Strtoi (UIDStr
);
1118 AsciiStr
= (CHAR8
*) ((UINT8
*)AcpiEx
+ sizeof (ACPI_EXTENDED_HID_DEVICE_PATH
));
1119 StrToAscii (HIDSTRStr
, &AsciiStr
);
1120 StrToAscii (UIDSTRStr
, &AsciiStr
);
1121 StrToAscii (CIDSTRStr
, &AsciiStr
);
1123 return (EFI_DEVICE_PATH_PROTOCOL
*) AcpiEx
;
1127 EFI_DEVICE_PATH_PROTOCOL
*
1128 DevPathFromTextAcpiExp (
1129 IN CHAR16
*TextDeviceNode
1137 ACPI_EXTENDED_HID_DEVICE_PATH
*AcpiEx
;
1139 HIDStr
= GetNextParamStr (&TextDeviceNode
);
1140 CIDStr
= GetNextParamStr (&TextDeviceNode
);
1141 UIDSTRStr
= GetNextParamStr (&TextDeviceNode
);
1142 Length
= (UINT16
) (sizeof (ACPI_EXTENDED_HID_DEVICE_PATH
) + StrLen (UIDSTRStr
) + 3);
1143 AcpiEx
= (ACPI_EXTENDED_HID_DEVICE_PATH
*) CreateDeviceNode (
1149 EisaIdFromText (HIDStr
, &AcpiEx
->HID
);
1150 EisaIdFromText (CIDStr
, &AcpiEx
->CID
);
1153 AsciiStr
= (CHAR8
*) ((UINT8
*)AcpiEx
+ sizeof (ACPI_EXTENDED_HID_DEVICE_PATH
));
1155 // HID string is NULL
1159 // Convert UID string
1162 StrToAscii (UIDSTRStr
, &AsciiStr
);
1164 // CID string is NULL
1168 return (EFI_DEVICE_PATH_PROTOCOL
*) AcpiEx
;
1172 EFI_DEVICE_PATH_PROTOCOL
*
1173 DevPathFromTextAta (
1174 IN CHAR16
*TextDeviceNode
1177 CHAR16
*PrimarySecondaryStr
;
1178 CHAR16
*SlaveMasterStr
;
1180 ATAPI_DEVICE_PATH
*Atapi
;
1182 Atapi
= (ATAPI_DEVICE_PATH
*) CreateDeviceNode (
1183 MESSAGING_DEVICE_PATH
,
1185 sizeof (ATAPI_DEVICE_PATH
)
1188 PrimarySecondaryStr
= GetNextParamStr (&TextDeviceNode
);
1189 SlaveMasterStr
= GetNextParamStr (&TextDeviceNode
);
1190 LunStr
= GetNextParamStr (&TextDeviceNode
);
1192 Atapi
->PrimarySecondary
= (UINT8
) ((StrCmp (PrimarySecondaryStr
, L
"Primary") == 0) ? 0 : 1);
1193 Atapi
->SlaveMaster
= (UINT8
) ((StrCmp (SlaveMasterStr
, L
"Master") == 0) ? 0 : 1);
1194 Atapi
->Lun
= (UINT16
) Strtoi (LunStr
);
1196 return (EFI_DEVICE_PATH_PROTOCOL
*) Atapi
;
1200 EFI_DEVICE_PATH_PROTOCOL
*
1201 DevPathFromTextScsi (
1202 IN CHAR16
*TextDeviceNode
1207 SCSI_DEVICE_PATH
*Scsi
;
1209 PunStr
= GetNextParamStr (&TextDeviceNode
);
1210 LunStr
= GetNextParamStr (&TextDeviceNode
);
1211 Scsi
= (SCSI_DEVICE_PATH
*) CreateDeviceNode (
1212 MESSAGING_DEVICE_PATH
,
1214 sizeof (SCSI_DEVICE_PATH
)
1217 Scsi
->Pun
= (UINT16
) Strtoi (PunStr
);
1218 Scsi
->Lun
= (UINT16
) Strtoi (LunStr
);
1220 return (EFI_DEVICE_PATH_PROTOCOL
*) Scsi
;
1224 EFI_DEVICE_PATH_PROTOCOL
*
1225 DevPathFromTextFibre (
1226 IN CHAR16
*TextDeviceNode
1231 FIBRECHANNEL_DEVICE_PATH
*Fibre
;
1233 WWNStr
= GetNextParamStr (&TextDeviceNode
);
1234 LunStr
= GetNextParamStr (&TextDeviceNode
);
1235 Fibre
= (FIBRECHANNEL_DEVICE_PATH
*) CreateDeviceNode (
1236 MESSAGING_DEVICE_PATH
,
1237 MSG_FIBRECHANNEL_DP
,
1238 sizeof (FIBRECHANNEL_DEVICE_PATH
)
1241 Fibre
->Reserved
= 0;
1242 Strtoi64 (WWNStr
, &Fibre
->WWN
);
1243 Strtoi64 (LunStr
, &Fibre
->Lun
);
1245 return (EFI_DEVICE_PATH_PROTOCOL
*) Fibre
;
1249 EFI_DEVICE_PATH_PROTOCOL
*
1250 DevPathFromText1394 (
1251 IN CHAR16
*TextDeviceNode
1255 F1394_DEVICE_PATH
*F1394
;
1257 GuidStr
= GetNextParamStr (&TextDeviceNode
);
1258 F1394
= (F1394_DEVICE_PATH
*) CreateDeviceNode (
1259 MESSAGING_DEVICE_PATH
,
1261 sizeof (F1394_DEVICE_PATH
)
1264 F1394
->Reserved
= 0;
1265 Xtoi64 (GuidStr
, &F1394
->Guid
);
1267 return (EFI_DEVICE_PATH_PROTOCOL
*) F1394
;
1271 EFI_DEVICE_PATH_PROTOCOL
*
1272 DevPathFromTextUsb (
1273 IN CHAR16
*TextDeviceNode
1277 CHAR16
*InterfaceStr
;
1278 USB_DEVICE_PATH
*Usb
;
1280 PortStr
= GetNextParamStr (&TextDeviceNode
);
1281 InterfaceStr
= GetNextParamStr (&TextDeviceNode
);
1282 Usb
= (USB_DEVICE_PATH
*) CreateDeviceNode (
1283 MESSAGING_DEVICE_PATH
,
1285 sizeof (USB_DEVICE_PATH
)
1288 Usb
->ParentPortNumber
= (UINT8
) Strtoi (PortStr
);
1289 Usb
->InterfaceNumber
= (UINT8
) Strtoi (InterfaceStr
);
1291 return (EFI_DEVICE_PATH_PROTOCOL
*) Usb
;
1295 EFI_DEVICE_PATH_PROTOCOL
*
1296 DevPathFromTextI2O (
1297 IN CHAR16
*TextDeviceNode
1301 I2O_DEVICE_PATH
*I2O
;
1303 TIDStr
= GetNextParamStr (&TextDeviceNode
);
1304 I2O
= (I2O_DEVICE_PATH
*) CreateDeviceNode (
1305 MESSAGING_DEVICE_PATH
,
1307 sizeof (I2O_DEVICE_PATH
)
1310 I2O
->Tid
= (UINT32
) Strtoi (TIDStr
);
1312 return (EFI_DEVICE_PATH_PROTOCOL
*) I2O
;
1316 EFI_DEVICE_PATH_PROTOCOL
*
1317 DevPathFromTextInfiniband (
1318 IN CHAR16
*TextDeviceNode
1327 INFINIBAND_DEVICE_PATH
*InfiniBand
;
1329 FlagsStr
= GetNextParamStr (&TextDeviceNode
);
1330 GuidStr
= GetNextParamStr (&TextDeviceNode
);
1331 SidStr
= GetNextParamStr (&TextDeviceNode
);
1332 TidStr
= GetNextParamStr (&TextDeviceNode
);
1333 DidStr
= GetNextParamStr (&TextDeviceNode
);
1334 InfiniBand
= (INFINIBAND_DEVICE_PATH
*) CreateDeviceNode (
1335 MESSAGING_DEVICE_PATH
,
1337 sizeof (INFINIBAND_DEVICE_PATH
)
1340 InfiniBand
->ResourceFlags
= (UINT32
) Strtoi (FlagsStr
);
1341 StrToGuid (GuidStr
, &PortGid
);
1342 CopyMem (InfiniBand
->PortGid
, &PortGid
, sizeof (EFI_GUID
));
1343 Strtoi64 (SidStr
, &InfiniBand
->ServiceId
);
1344 Strtoi64 (TidStr
, &InfiniBand
->TargetPortId
);
1345 Strtoi64 (DidStr
, &InfiniBand
->DeviceId
);
1347 return (EFI_DEVICE_PATH_PROTOCOL
*) InfiniBand
;
1351 EFI_DEVICE_PATH_PROTOCOL
*
1352 DevPathFromTextVenMsg (
1353 IN CHAR16
*TextDeviceNode
1356 return ConvertFromTextVendor (
1358 MESSAGING_DEVICE_PATH
,
1364 EFI_DEVICE_PATH_PROTOCOL
*
1365 DevPathFromTextVenPcAnsi (
1366 IN CHAR16
*TextDeviceNode
1369 VENDOR_DEVICE_PATH
*Vendor
;
1371 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
1372 MESSAGING_DEVICE_PATH
,
1374 sizeof (VENDOR_DEVICE_PATH
));
1375 CopyGuid (&Vendor
->Guid
, &gEfiPcAnsiGuid
);
1377 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
1381 EFI_DEVICE_PATH_PROTOCOL
*
1382 DevPathFromTextVenVt100 (
1383 IN CHAR16
*TextDeviceNode
1386 VENDOR_DEVICE_PATH
*Vendor
;
1388 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
1389 MESSAGING_DEVICE_PATH
,
1391 sizeof (VENDOR_DEVICE_PATH
));
1392 CopyGuid (&Vendor
->Guid
, &gEfiVT100Guid
);
1394 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
1398 EFI_DEVICE_PATH_PROTOCOL
*
1399 DevPathFromTextVenVt100Plus (
1400 IN CHAR16
*TextDeviceNode
1403 VENDOR_DEVICE_PATH
*Vendor
;
1405 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
1406 MESSAGING_DEVICE_PATH
,
1408 sizeof (VENDOR_DEVICE_PATH
));
1409 CopyGuid (&Vendor
->Guid
, &gEfiVT100PlusGuid
);
1411 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
1415 EFI_DEVICE_PATH_PROTOCOL
*
1416 DevPathFromTextVenUtf8 (
1417 IN CHAR16
*TextDeviceNode
1420 VENDOR_DEVICE_PATH
*Vendor
;
1422 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
1423 MESSAGING_DEVICE_PATH
,
1425 sizeof (VENDOR_DEVICE_PATH
));
1426 CopyGuid (&Vendor
->Guid
, &gEfiVTUTF8Guid
);
1428 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
1432 EFI_DEVICE_PATH_PROTOCOL
*
1433 DevPathFromTextUartFlowCtrl (
1434 IN CHAR16
*TextDeviceNode
1438 UART_FLOW_CONTROL_DEVICE_PATH
*UartFlowControl
;
1440 ValueStr
= GetNextParamStr (&TextDeviceNode
);
1441 UartFlowControl
= (UART_FLOW_CONTROL_DEVICE_PATH
*) CreateDeviceNode (
1442 MESSAGING_DEVICE_PATH
,
1444 sizeof (UART_FLOW_CONTROL_DEVICE_PATH
)
1447 CopyGuid (&UartFlowControl
->Guid
, &mEfiDevicePathMessagingUartFlowControlGuid
);
1448 if (StrCmp (ValueStr
, L
"XonXoff") == 0) {
1449 UartFlowControl
->FlowControlMap
= 2;
1450 } else if (StrCmp (ValueStr
, L
"Hardware") == 0) {
1451 UartFlowControl
->FlowControlMap
= 1;
1453 UartFlowControl
->FlowControlMap
= 0;
1456 return (EFI_DEVICE_PATH_PROTOCOL
*) UartFlowControl
;
1460 EFI_DEVICE_PATH_PROTOCOL
*
1461 DevPathFromTextSAS (
1462 IN CHAR16
*TextDeviceNode
1469 CHAR16
*LocationStr
;
1471 CHAR16
*DriveBayStr
;
1472 CHAR16
*ReservedStr
;
1474 SAS_DEVICE_PATH
*Sas
;
1476 AddressStr
= GetNextParamStr (&TextDeviceNode
);
1477 LunStr
= GetNextParamStr (&TextDeviceNode
);
1478 RTPStr
= GetNextParamStr (&TextDeviceNode
);
1479 SASSATAStr
= GetNextParamStr (&TextDeviceNode
);
1480 LocationStr
= GetNextParamStr (&TextDeviceNode
);
1481 ConnectStr
= GetNextParamStr (&TextDeviceNode
);
1482 DriveBayStr
= GetNextParamStr (&TextDeviceNode
);
1483 ReservedStr
= GetNextParamStr (&TextDeviceNode
);
1485 Sas
= (SAS_DEVICE_PATH
*) CreateDeviceNode (
1486 MESSAGING_DEVICE_PATH
,
1488 sizeof (SAS_DEVICE_PATH
)
1491 CopyGuid (&Sas
->Guid
, &mEfiDevicePathMessagingSASGuid
);
1492 Strtoi64 (AddressStr
, &Sas
->SasAddress
);
1493 Strtoi64 (LunStr
, &Sas
->Lun
);
1494 Sas
->RelativeTargetPort
= (UINT16
) Strtoi (RTPStr
);
1495 if (StrCmp (SASSATAStr
, L
"NoTopology") != 0) {
1496 if (StrCmp (DriveBayStr
, L
"0") == 0) {
1500 Info
= (UINT16
) (Info
| (Strtoi (DriveBayStr
) << 8));
1503 if (StrCmp (SASSATAStr
, L
"SATA") == 0) {
1507 if (StrCmp (LocationStr
, L
"External") == 0) {
1511 if (StrCmp (ConnectStr
, L
"Expanded") == 0) {
1516 Sas
->DeviceTopology
= Info
;
1517 Sas
->Reserved
= (UINT32
) Strtoi (ReservedStr
);
1519 return (EFI_DEVICE_PATH_PROTOCOL
*) Sas
;
1523 EFI_DEVICE_PATH_PROTOCOL
*
1524 DevPathFromTextDebugPort (
1525 IN CHAR16
*TextDeviceNode
1528 VENDOR_DEFINED_MESSAGING_DEVICE_PATH
*Vend
;
1530 Vend
= (VENDOR_DEFINED_MESSAGING_DEVICE_PATH
*) CreateDeviceNode (
1531 MESSAGING_DEVICE_PATH
,
1533 sizeof (VENDOR_DEFINED_MESSAGING_DEVICE_PATH
)
1536 CopyGuid (&Vend
->Guid
, &gEfiDebugPortProtocolGuid
);
1538 return (EFI_DEVICE_PATH_PROTOCOL
*) Vend
;
1542 EFI_DEVICE_PATH_PROTOCOL
*
1543 DevPathFromTextMAC (
1544 IN CHAR16
*TextDeviceNode
1550 MAC_ADDR_DEVICE_PATH
*MAC
;
1552 AddressStr
= GetNextParamStr (&TextDeviceNode
);
1553 IfTypeStr
= GetNextParamStr (&TextDeviceNode
);
1554 MAC
= (MAC_ADDR_DEVICE_PATH
*) CreateDeviceNode (
1555 MESSAGING_DEVICE_PATH
,
1557 sizeof (MAC_ADDR_DEVICE_PATH
)
1560 MAC
->IfType
= (UINT8
) Strtoi (IfTypeStr
);
1562 Length
= sizeof (EFI_MAC_ADDRESS
);
1563 StrToBuf (&MAC
->MacAddress
.Addr
[0], Length
, AddressStr
);
1565 return (EFI_DEVICE_PATH_PROTOCOL
*) MAC
;
1569 EFI_DEVICE_PATH_PROTOCOL
*
1570 DevPathFromTextIPv4 (
1571 IN CHAR16
*TextDeviceNode
1574 CHAR16
*RemoteIPStr
;
1575 CHAR16
*ProtocolStr
;
1578 IPv4_DEVICE_PATH
*IPv4
;
1580 RemoteIPStr
= GetNextParamStr (&TextDeviceNode
);
1581 ProtocolStr
= GetNextParamStr (&TextDeviceNode
);
1582 TypeStr
= GetNextParamStr (&TextDeviceNode
);
1583 LocalIPStr
= GetNextParamStr (&TextDeviceNode
);
1584 IPv4
= (IPv4_DEVICE_PATH
*) CreateDeviceNode (
1585 MESSAGING_DEVICE_PATH
,
1587 sizeof (IPv4_DEVICE_PATH
)
1590 StrToIPv4Addr (&RemoteIPStr
, &IPv4
->RemoteIpAddress
);
1591 IPv4
->Protocol
= (UINT16
) ((StrCmp (ProtocolStr
, L
"UDP") == 0) ? 0 : 1);
1592 if (StrCmp (TypeStr
, L
"Static") == 0) {
1593 IPv4
->StaticIpAddress
= TRUE
;
1595 IPv4
->StaticIpAddress
= FALSE
;
1598 StrToIPv4Addr (&LocalIPStr
, &IPv4
->LocalIpAddress
);
1600 IPv4
->LocalPort
= 0;
1601 IPv4
->RemotePort
= 0;
1603 return (EFI_DEVICE_PATH_PROTOCOL
*) IPv4
;
1607 EFI_DEVICE_PATH_PROTOCOL
*
1608 DevPathFromTextIPv6 (
1609 IN CHAR16
*TextDeviceNode
1612 CHAR16
*RemoteIPStr
;
1613 CHAR16
*ProtocolStr
;
1616 IPv6_DEVICE_PATH
*IPv6
;
1618 RemoteIPStr
= GetNextParamStr (&TextDeviceNode
);
1619 ProtocolStr
= GetNextParamStr (&TextDeviceNode
);
1620 TypeStr
= GetNextParamStr (&TextDeviceNode
);
1621 LocalIPStr
= GetNextParamStr (&TextDeviceNode
);
1622 IPv6
= (IPv6_DEVICE_PATH
*) CreateDeviceNode (
1623 MESSAGING_DEVICE_PATH
,
1625 sizeof (IPv6_DEVICE_PATH
)
1628 StrToIPv6Addr (&RemoteIPStr
, &IPv6
->RemoteIpAddress
);
1629 IPv6
->Protocol
= (UINT16
) ((StrCmp (ProtocolStr
, L
"UDP") == 0) ? 0 : 1);
1630 if (StrCmp (TypeStr
, L
"Static") == 0) {
1631 IPv6
->StaticIpAddress
= TRUE
;
1633 IPv6
->StaticIpAddress
= FALSE
;
1636 StrToIPv6Addr (&LocalIPStr
, &IPv6
->LocalIpAddress
);
1638 IPv6
->LocalPort
= 0;
1639 IPv6
->RemotePort
= 0;
1641 return (EFI_DEVICE_PATH_PROTOCOL
*) IPv6
;
1645 EFI_DEVICE_PATH_PROTOCOL
*
1646 DevPathFromTextUart (
1647 IN CHAR16
*TextDeviceNode
1651 CHAR16
*DataBitsStr
;
1653 CHAR16
*StopBitsStr
;
1654 UART_DEVICE_PATH
*Uart
;
1656 BaudStr
= GetNextParamStr (&TextDeviceNode
);
1657 DataBitsStr
= GetNextParamStr (&TextDeviceNode
);
1658 ParityStr
= GetNextParamStr (&TextDeviceNode
);
1659 StopBitsStr
= GetNextParamStr (&TextDeviceNode
);
1660 Uart
= (UART_DEVICE_PATH
*) CreateDeviceNode (
1661 MESSAGING_DEVICE_PATH
,
1663 sizeof (UART_DEVICE_PATH
)
1666 Uart
->BaudRate
= (StrCmp (BaudStr
, L
"DEFAULT") == 0) ? 115200 : Dtoi (BaudStr
);
1667 Uart
->DataBits
= (UINT8
) ((StrCmp (DataBitsStr
, L
"DEFAULT") == 0) ? 8 : Dtoi (DataBitsStr
));
1668 switch (*ParityStr
) {
1693 Uart
->Parity
= 0xff;
1696 if (StrCmp (StopBitsStr
, L
"D") == 0) {
1697 Uart
->StopBits
= (UINT8
) 0;
1698 } else if (StrCmp (StopBitsStr
, L
"1") == 0) {
1699 Uart
->StopBits
= (UINT8
) 1;
1700 } else if (StrCmp (StopBitsStr
, L
"1.5") == 0) {
1701 Uart
->StopBits
= (UINT8
) 2;
1702 } else if (StrCmp (StopBitsStr
, L
"2") == 0) {
1703 Uart
->StopBits
= (UINT8
) 3;
1705 Uart
->StopBits
= 0xff;
1708 return (EFI_DEVICE_PATH_PROTOCOL
*) Uart
;
1712 EFI_DEVICE_PATH_PROTOCOL
*
1713 ConvertFromTextUsbClass (
1714 IN CHAR16
*TextDeviceNode
,
1715 IN USB_CLASS_TEXT
*UsbClassText
1721 CHAR16
*SubClassStr
;
1722 CHAR16
*ProtocolStr
;
1723 USB_CLASS_DEVICE_PATH
*UsbClass
;
1725 UsbClass
= (USB_CLASS_DEVICE_PATH
*) CreateDeviceNode (
1726 MESSAGING_DEVICE_PATH
,
1728 sizeof (USB_CLASS_DEVICE_PATH
)
1731 VIDStr
= GetNextParamStr (&TextDeviceNode
);
1732 PIDStr
= GetNextParamStr (&TextDeviceNode
);
1733 if (UsbClassText
->ClassExist
) {
1734 ClassStr
= GetNextParamStr (&TextDeviceNode
);
1735 UsbClass
->DeviceClass
= (UINT8
) Strtoi (ClassStr
);
1737 UsbClass
->DeviceClass
= UsbClassText
->Class
;
1739 if (UsbClassText
->SubClassExist
) {
1740 SubClassStr
= GetNextParamStr (&TextDeviceNode
);
1741 UsbClass
->DeviceSubClass
= (UINT8
) Strtoi (SubClassStr
);
1743 UsbClass
->DeviceSubClass
= UsbClassText
->SubClass
;
1746 ProtocolStr
= GetNextParamStr (&TextDeviceNode
);
1748 UsbClass
->VendorId
= (UINT16
) Strtoi (VIDStr
);
1749 UsbClass
->ProductId
= (UINT16
) Strtoi (PIDStr
);
1750 UsbClass
->DeviceProtocol
= (UINT8
) Strtoi (ProtocolStr
);
1752 return (EFI_DEVICE_PATH_PROTOCOL
*) UsbClass
;
1757 EFI_DEVICE_PATH_PROTOCOL
*
1758 DevPathFromTextUsbClass (
1759 IN CHAR16
*TextDeviceNode
1762 USB_CLASS_TEXT UsbClassText
;
1764 UsbClassText
.ClassExist
= TRUE
;
1765 UsbClassText
.SubClassExist
= TRUE
;
1767 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1771 EFI_DEVICE_PATH_PROTOCOL
*
1772 DevPathFromTextUsbAudio (
1773 IN CHAR16
*TextDeviceNode
1776 USB_CLASS_TEXT UsbClassText
;
1778 UsbClassText
.ClassExist
= FALSE
;
1779 UsbClassText
.Class
= USB_CLASS_AUDIO
;
1780 UsbClassText
.SubClassExist
= TRUE
;
1782 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1786 EFI_DEVICE_PATH_PROTOCOL
*
1787 DevPathFromTextUsbCDCControl (
1788 IN CHAR16
*TextDeviceNode
1791 USB_CLASS_TEXT UsbClassText
;
1793 UsbClassText
.ClassExist
= FALSE
;
1794 UsbClassText
.Class
= USB_CLASS_CDCCONTROL
;
1795 UsbClassText
.SubClassExist
= TRUE
;
1797 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1801 EFI_DEVICE_PATH_PROTOCOL
*
1802 DevPathFromTextUsbHID (
1803 IN CHAR16
*TextDeviceNode
1806 USB_CLASS_TEXT UsbClassText
;
1808 UsbClassText
.ClassExist
= FALSE
;
1809 UsbClassText
.Class
= USB_CLASS_HID
;
1810 UsbClassText
.SubClassExist
= TRUE
;
1812 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1816 EFI_DEVICE_PATH_PROTOCOL
*
1817 DevPathFromTextUsbImage (
1818 IN CHAR16
*TextDeviceNode
1821 USB_CLASS_TEXT UsbClassText
;
1823 UsbClassText
.ClassExist
= FALSE
;
1824 UsbClassText
.Class
= USB_CLASS_IMAGE
;
1825 UsbClassText
.SubClassExist
= TRUE
;
1827 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1831 EFI_DEVICE_PATH_PROTOCOL
*
1832 DevPathFromTextUsbPrinter (
1833 IN CHAR16
*TextDeviceNode
1836 USB_CLASS_TEXT UsbClassText
;
1838 UsbClassText
.ClassExist
= FALSE
;
1839 UsbClassText
.Class
= USB_CLASS_PRINTER
;
1840 UsbClassText
.SubClassExist
= TRUE
;
1842 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1846 EFI_DEVICE_PATH_PROTOCOL
*
1847 DevPathFromTextUsbMassStorage (
1848 IN CHAR16
*TextDeviceNode
1851 USB_CLASS_TEXT UsbClassText
;
1853 UsbClassText
.ClassExist
= FALSE
;
1854 UsbClassText
.Class
= USB_CLASS_MASS_STORAGE
;
1855 UsbClassText
.SubClassExist
= TRUE
;
1857 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1861 EFI_DEVICE_PATH_PROTOCOL
*
1862 DevPathFromTextUsbHub (
1863 IN CHAR16
*TextDeviceNode
1866 USB_CLASS_TEXT UsbClassText
;
1868 UsbClassText
.ClassExist
= FALSE
;
1869 UsbClassText
.Class
= USB_CLASS_HUB
;
1870 UsbClassText
.SubClassExist
= TRUE
;
1872 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1876 EFI_DEVICE_PATH_PROTOCOL
*
1877 DevPathFromTextUsbCDCData (
1878 IN CHAR16
*TextDeviceNode
1881 USB_CLASS_TEXT UsbClassText
;
1883 UsbClassText
.ClassExist
= FALSE
;
1884 UsbClassText
.Class
= USB_CLASS_CDCDATA
;
1885 UsbClassText
.SubClassExist
= TRUE
;
1887 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1891 EFI_DEVICE_PATH_PROTOCOL
*
1892 DevPathFromTextUsbSmartCard (
1893 IN CHAR16
*TextDeviceNode
1896 USB_CLASS_TEXT UsbClassText
;
1898 UsbClassText
.ClassExist
= FALSE
;
1899 UsbClassText
.Class
= USB_CLASS_SMART_CARD
;
1900 UsbClassText
.SubClassExist
= TRUE
;
1902 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1906 EFI_DEVICE_PATH_PROTOCOL
*
1907 DevPathFromTextUsbVideo (
1908 IN CHAR16
*TextDeviceNode
1911 USB_CLASS_TEXT UsbClassText
;
1913 UsbClassText
.ClassExist
= FALSE
;
1914 UsbClassText
.Class
= USB_CLASS_VIDEO
;
1915 UsbClassText
.SubClassExist
= TRUE
;
1917 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1921 EFI_DEVICE_PATH_PROTOCOL
*
1922 DevPathFromTextUsbDiagnostic (
1923 IN CHAR16
*TextDeviceNode
1926 USB_CLASS_TEXT UsbClassText
;
1928 UsbClassText
.ClassExist
= FALSE
;
1929 UsbClassText
.Class
= USB_CLASS_DIAGNOSTIC
;
1930 UsbClassText
.SubClassExist
= TRUE
;
1932 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1936 EFI_DEVICE_PATH_PROTOCOL
*
1937 DevPathFromTextUsbWireless (
1938 IN CHAR16
*TextDeviceNode
1941 USB_CLASS_TEXT UsbClassText
;
1943 UsbClassText
.ClassExist
= FALSE
;
1944 UsbClassText
.Class
= USB_CLASS_WIRELESS
;
1945 UsbClassText
.SubClassExist
= TRUE
;
1947 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1951 EFI_DEVICE_PATH_PROTOCOL
*
1952 DevPathFromTextUsbDeviceFirmwareUpdate (
1953 IN CHAR16
*TextDeviceNode
1956 USB_CLASS_TEXT UsbClassText
;
1958 UsbClassText
.ClassExist
= FALSE
;
1959 UsbClassText
.Class
= USB_CLASS_RESERVE
;
1960 UsbClassText
.SubClassExist
= FALSE
;
1961 UsbClassText
.SubClass
= USB_SUBCLASS_FW_UPDATE
;
1963 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1967 EFI_DEVICE_PATH_PROTOCOL
*
1968 DevPathFromTextUsbIrdaBridge (
1969 IN CHAR16
*TextDeviceNode
1972 USB_CLASS_TEXT UsbClassText
;
1974 UsbClassText
.ClassExist
= FALSE
;
1975 UsbClassText
.Class
= USB_CLASS_RESERVE
;
1976 UsbClassText
.SubClassExist
= FALSE
;
1977 UsbClassText
.SubClass
= USB_SUBCLASS_IRDA_BRIDGE
;
1979 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1983 EFI_DEVICE_PATH_PROTOCOL
*
1984 DevPathFromTextUsbTestAndMeasurement (
1985 IN CHAR16
*TextDeviceNode
1988 USB_CLASS_TEXT UsbClassText
;
1990 UsbClassText
.ClassExist
= FALSE
;
1991 UsbClassText
.Class
= USB_CLASS_RESERVE
;
1992 UsbClassText
.SubClassExist
= FALSE
;
1993 UsbClassText
.SubClass
= USB_SUBCLASS_TEST
;
1995 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1999 EFI_DEVICE_PATH_PROTOCOL
*
2000 DevPathFromTextUsbWwid (
2001 IN CHAR16
*TextDeviceNode
2006 CHAR16
*InterfaceNumStr
;
2007 CHAR16
*SerialNumberStr
;
2008 USB_WWID_DEVICE_PATH
*UsbWwid
;
2010 VIDStr
= GetNextParamStr (&TextDeviceNode
);
2011 PIDStr
= GetNextParamStr (&TextDeviceNode
);
2012 InterfaceNumStr
= GetNextParamStr (&TextDeviceNode
);
2013 SerialNumberStr
= GetNextParamStr (&TextDeviceNode
);
2014 UsbWwid
= (USB_WWID_DEVICE_PATH
*) CreateDeviceNode (
2015 MESSAGING_DEVICE_PATH
,
2017 (UINT16
) (sizeof (USB_WWID_DEVICE_PATH
) + StrSize (SerialNumberStr
))
2020 UsbWwid
->VendorId
= (UINT16
) Strtoi (VIDStr
);
2021 UsbWwid
->ProductId
= (UINT16
) Strtoi (PIDStr
);
2022 UsbWwid
->InterfaceNumber
= (UINT16
) Strtoi (InterfaceNumStr
);
2023 StrCpy ((CHAR16
*) ((UINT8
*) UsbWwid
+ sizeof (USB_WWID_DEVICE_PATH
)), SerialNumberStr
);
2025 return (EFI_DEVICE_PATH_PROTOCOL
*) UsbWwid
;
2029 EFI_DEVICE_PATH_PROTOCOL
*
2030 DevPathFromTextUnit (
2031 IN CHAR16
*TextDeviceNode
2035 DEVICE_LOGICAL_UNIT_DEVICE_PATH
*LogicalUnit
;
2037 LunStr
= GetNextParamStr (&TextDeviceNode
);
2038 LogicalUnit
= (DEVICE_LOGICAL_UNIT_DEVICE_PATH
*) CreateDeviceNode (
2039 MESSAGING_DEVICE_PATH
,
2040 MSG_DEVICE_LOGICAL_UNIT_DP
,
2041 (UINT16
) sizeof (DEVICE_LOGICAL_UNIT_DEVICE_PATH
)
2044 LogicalUnit
->Lun
= (UINT8
) Strtoi (LunStr
);
2046 return (EFI_DEVICE_PATH_PROTOCOL
*) LogicalUnit
;
2050 EFI_DEVICE_PATH_PROTOCOL
*
2051 DevPathFromTextiSCSI (
2052 IN CHAR16
*TextDeviceNode
2057 CHAR16
*PortalGroupStr
;
2059 CHAR16
*HeaderDigestStr
;
2060 CHAR16
*DataDigestStr
;
2061 CHAR16
*AuthenticationStr
;
2062 CHAR16
*ProtocolStr
;
2064 ISCSI_DEVICE_PATH_WITH_NAME
*iSCSI
;
2066 NameStr
= GetNextParamStr (&TextDeviceNode
);
2067 PortalGroupStr
= GetNextParamStr (&TextDeviceNode
);
2068 LunStr
= GetNextParamStr (&TextDeviceNode
);
2069 HeaderDigestStr
= GetNextParamStr (&TextDeviceNode
);
2070 DataDigestStr
= GetNextParamStr (&TextDeviceNode
);
2071 AuthenticationStr
= GetNextParamStr (&TextDeviceNode
);
2072 ProtocolStr
= GetNextParamStr (&TextDeviceNode
);
2073 iSCSI
= (ISCSI_DEVICE_PATH_WITH_NAME
*) CreateDeviceNode (
2074 MESSAGING_DEVICE_PATH
,
2076 (UINT16
) (sizeof (ISCSI_DEVICE_PATH_WITH_NAME
) + StrLen (NameStr
))
2079 AsciiStr
= iSCSI
->iSCSITargetName
;
2080 StrToAscii (NameStr
, &AsciiStr
);
2082 iSCSI
->TargetPortalGroupTag
= (UINT16
) Strtoi (PortalGroupStr
);
2083 Strtoi64 (LunStr
, &iSCSI
->Lun
);
2086 if (StrCmp (HeaderDigestStr
, L
"CRC32C") == 0) {
2090 if (StrCmp (DataDigestStr
, L
"CRC32C") == 0) {
2094 if (StrCmp (AuthenticationStr
, L
"None") == 0) {
2098 if (StrCmp (AuthenticationStr
, L
"CHAP_UNI") == 0) {
2102 iSCSI
->LoginOption
= (UINT16
) Options
;
2104 iSCSI
->NetworkProtocol
= (UINT16
) StrCmp (ProtocolStr
, L
"TCP");
2106 return (EFI_DEVICE_PATH_PROTOCOL
*) iSCSI
;
2110 EFI_DEVICE_PATH_PROTOCOL
*
2112 IN CHAR16
*TextDeviceNode
2115 CHAR16
*PartitionStr
;
2117 CHAR16
*SignatureStr
;
2121 EFI_GUID SignatureGuid
;
2122 HARDDRIVE_DEVICE_PATH
*Hd
;
2124 PartitionStr
= GetNextParamStr (&TextDeviceNode
);
2125 TypeStr
= GetNextParamStr (&TextDeviceNode
);
2126 SignatureStr
= GetNextParamStr (&TextDeviceNode
);
2127 StartStr
= GetNextParamStr (&TextDeviceNode
);
2128 SizeStr
= GetNextParamStr (&TextDeviceNode
);
2129 Hd
= (HARDDRIVE_DEVICE_PATH
*) CreateDeviceNode (
2132 sizeof (HARDDRIVE_DEVICE_PATH
)
2135 Hd
->PartitionNumber
= (UINT32
) Dtoi (PartitionStr
);
2137 ZeroMem (Hd
->Signature
, 16);
2138 Hd
->MBRType
= (UINT8
) 0;
2140 if (StrCmp (TypeStr
, L
"MBR") == 0) {
2141 Hd
->SignatureType
= SIGNATURE_TYPE_MBR
;
2144 Signature32
= (UINT32
) Strtoi (SignatureStr
);
2145 CopyMem (Hd
->Signature
, &Signature32
, sizeof (UINT32
));
2146 } else if (StrCmp (TypeStr
, L
"GPT") == 0) {
2147 Hd
->SignatureType
= SIGNATURE_TYPE_GUID
;
2150 StrToGuid (SignatureStr
, &SignatureGuid
);
2151 CopyMem (Hd
->Signature
, &SignatureGuid
, sizeof (EFI_GUID
));
2153 Hd
->SignatureType
= (UINT8
) Strtoi (TypeStr
);
2156 Strtoi64 (StartStr
, &Hd
->PartitionStart
);
2157 Strtoi64 (SizeStr
, &Hd
->PartitionSize
);
2159 return (EFI_DEVICE_PATH_PROTOCOL
*) Hd
;
2163 EFI_DEVICE_PATH_PROTOCOL
*
2164 DevPathFromTextCDROM (
2165 IN CHAR16
*TextDeviceNode
2171 CDROM_DEVICE_PATH
*CDROM
;
2173 EntryStr
= GetNextParamStr (&TextDeviceNode
);
2174 StartStr
= GetNextParamStr (&TextDeviceNode
);
2175 SizeStr
= GetNextParamStr (&TextDeviceNode
);
2176 CDROM
= (CDROM_DEVICE_PATH
*) CreateDeviceNode (
2179 sizeof (CDROM_DEVICE_PATH
)
2182 CDROM
->BootEntry
= (UINT32
) Strtoi (EntryStr
);
2183 Strtoi64 (StartStr
, &CDROM
->PartitionStart
);
2184 Strtoi64 (SizeStr
, &CDROM
->PartitionSize
);
2186 return (EFI_DEVICE_PATH_PROTOCOL
*) CDROM
;
2190 EFI_DEVICE_PATH_PROTOCOL
*
2191 DevPathFromTextVenMEDIA (
2192 IN CHAR16
*TextDeviceNode
2195 return ConvertFromTextVendor (
2203 EFI_DEVICE_PATH_PROTOCOL
*
2204 DevPathFromTextFilePath (
2205 IN CHAR16
*TextDeviceNode
2208 FILEPATH_DEVICE_PATH
*File
;
2210 File
= (FILEPATH_DEVICE_PATH
*) CreateDeviceNode (
2213 (UINT16
) (sizeof (FILEPATH_DEVICE_PATH
) + StrLen (TextDeviceNode
) * 2)
2216 StrCpy (File
->PathName
, TextDeviceNode
);
2218 return (EFI_DEVICE_PATH_PROTOCOL
*) File
;
2222 EFI_DEVICE_PATH_PROTOCOL
*
2223 DevPathFromTextMedia (
2224 IN CHAR16
*TextDeviceNode
2228 MEDIA_PROTOCOL_DEVICE_PATH
*Media
;
2230 GuidStr
= GetNextParamStr (&TextDeviceNode
);
2231 Media
= (MEDIA_PROTOCOL_DEVICE_PATH
*) CreateDeviceNode (
2234 sizeof (MEDIA_PROTOCOL_DEVICE_PATH
)
2237 StrToGuid (GuidStr
, &Media
->Protocol
);
2239 return (EFI_DEVICE_PATH_PROTOCOL
*) Media
;
2243 EFI_DEVICE_PATH_PROTOCOL
*
2245 IN CHAR16
*TextDeviceNode
2249 MEDIA_FW_VOL_DEVICE_PATH
*Fv
;
2251 GuidStr
= GetNextParamStr (&TextDeviceNode
);
2252 Fv
= (MEDIA_FW_VOL_DEVICE_PATH
*) CreateDeviceNode (
2254 MEDIA_PIWG_FW_VOL_DP
,
2255 sizeof (MEDIA_FW_VOL_DEVICE_PATH
)
2258 StrToGuid (GuidStr
, &Fv
->FvName
);
2260 return (EFI_DEVICE_PATH_PROTOCOL
*) Fv
;
2264 EFI_DEVICE_PATH_PROTOCOL
*
2265 DevPathFromTextFvFile (
2266 IN CHAR16
*TextDeviceNode
2270 MEDIA_FW_VOL_FILEPATH_DEVICE_PATH
*FvFile
;
2272 GuidStr
= GetNextParamStr (&TextDeviceNode
);
2273 FvFile
= (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH
*) CreateDeviceNode (
2275 MEDIA_PIWG_FW_FILE_DP
,
2276 sizeof (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH
)
2279 StrToGuid (GuidStr
, &FvFile
->FvFileName
);
2281 return (EFI_DEVICE_PATH_PROTOCOL
*) FvFile
;
2285 EFI_DEVICE_PATH_PROTOCOL
*
2286 DevPathFromTextBBS (
2287 IN CHAR16
*TextDeviceNode
2294 BBS_BBS_DEVICE_PATH
*Bbs
;
2296 TypeStr
= GetNextParamStr (&TextDeviceNode
);
2297 IdStr
= GetNextParamStr (&TextDeviceNode
);
2298 FlagsStr
= GetNextParamStr (&TextDeviceNode
);
2299 Bbs
= (BBS_BBS_DEVICE_PATH
*) CreateDeviceNode (
2302 (UINT16
) (sizeof (BBS_BBS_DEVICE_PATH
) + StrLen (IdStr
))
2305 if (StrCmp (TypeStr
, L
"Floppy") == 0) {
2306 Bbs
->DeviceType
= BBS_TYPE_FLOPPY
;
2307 } else if (StrCmp (TypeStr
, L
"HD") == 0) {
2308 Bbs
->DeviceType
= BBS_TYPE_HARDDRIVE
;
2309 } else if (StrCmp (TypeStr
, L
"CDROM") == 0) {
2310 Bbs
->DeviceType
= BBS_TYPE_CDROM
;
2311 } else if (StrCmp (TypeStr
, L
"PCMCIA") == 0) {
2312 Bbs
->DeviceType
= BBS_TYPE_PCMCIA
;
2313 } else if (StrCmp (TypeStr
, L
"USB") == 0) {
2314 Bbs
->DeviceType
= BBS_TYPE_USB
;
2315 } else if (StrCmp (TypeStr
, L
"Network") == 0) {
2316 Bbs
->DeviceType
= BBS_TYPE_EMBEDDED_NETWORK
;
2318 Bbs
->DeviceType
= (UINT16
) Strtoi (TypeStr
);
2321 AsciiStr
= Bbs
->String
;
2322 StrToAscii (IdStr
, &AsciiStr
);
2324 Bbs
->StatusFlag
= (UINT16
) Strtoi (FlagsStr
);
2326 return (EFI_DEVICE_PATH_PROTOCOL
*) Bbs
;
2330 EFI_DEVICE_PATH_PROTOCOL
*
2331 DevPathFromTextSata (
2332 IN CHAR16
*TextDeviceNode
2335 SATA_DEVICE_PATH
*Sata
;
2341 // The PMPN is optional.
2343 Param1
= GetNextParamStr (&TextDeviceNode
);
2344 Param2
= GetNextParamStr (&TextDeviceNode
);
2346 if (!IS_NULL (TextDeviceNode
)) {
2347 Param3
= GetNextParamStr (&TextDeviceNode
);
2350 Sata
= (SATA_DEVICE_PATH
*) CreateDeviceNode (
2351 MESSAGING_DEVICE_PATH
,
2353 sizeof (SATA_DEVICE_PATH
)
2355 Sata
->HBAPortNumber
= (UINT16
) Xtoi (Param1
);
2356 if (Param3
!= NULL
) {
2357 Sata
->PortMultiplierPortNumber
= (UINT16
) Xtoi (Param2
);
2360 Sata
->PortMultiplierPortNumber
= 0;
2362 Sata
->Lun
= (UINT16
) Xtoi (Param2
);
2364 return (EFI_DEVICE_PATH_PROTOCOL
*) Sata
;
2367 GLOBAL_REMOVE_IF_UNREFERENCED DEVICE_PATH_FROM_TEXT_TABLE DevPathFromTextTable
[] = {
2368 {L
"Pci", DevPathFromTextPci
},
2369 {L
"PcCard", DevPathFromTextPcCard
},
2370 {L
"MemoryMapped", DevPathFromTextMemoryMapped
},
2371 {L
"VenHw", DevPathFromTextVenHw
},
2372 {L
"Ctrl", DevPathFromTextCtrl
},
2373 {L
"Acpi", DevPathFromTextAcpi
},
2374 {L
"PciRoot", DevPathFromTextPciRoot
},
2375 {L
"Floppy", DevPathFromTextFloppy
},
2376 {L
"Keyboard", DevPathFromTextKeyboard
},
2377 {L
"Serial", DevPathFromTextSerial
},
2378 {L
"ParallelPort", DevPathFromTextParallelPort
},
2379 {L
"AcpiEx", DevPathFromTextAcpiEx
},
2380 {L
"AcpiExp", DevPathFromTextAcpiExp
},
2381 {L
"Ata", DevPathFromTextAta
},
2382 {L
"Scsi", DevPathFromTextScsi
},
2383 {L
"Fibre", DevPathFromTextFibre
},
2384 {L
"I1394", DevPathFromText1394
},
2385 {L
"USB", DevPathFromTextUsb
},
2386 {L
"I2O", DevPathFromTextI2O
},
2387 {L
"Infiniband", DevPathFromTextInfiniband
},
2388 {L
"VenMsg", DevPathFromTextVenMsg
},
2389 {L
"VenPcAnsi", DevPathFromTextVenPcAnsi
},
2390 {L
"VenVt100", DevPathFromTextVenVt100
},
2391 {L
"VenVt100Plus", DevPathFromTextVenVt100Plus
},
2392 {L
"VenUtf8", DevPathFromTextVenUtf8
},
2393 {L
"UartFlowCtrl", DevPathFromTextUartFlowCtrl
},
2394 {L
"SAS", DevPathFromTextSAS
},
2395 {L
"DebugPort", DevPathFromTextDebugPort
},
2396 {L
"MAC", DevPathFromTextMAC
},
2397 {L
"IPv4", DevPathFromTextIPv4
},
2398 {L
"IPv6", DevPathFromTextIPv6
},
2399 {L
"Uart", DevPathFromTextUart
},
2400 {L
"UsbClass", DevPathFromTextUsbClass
},
2401 {L
"UsbAudio", DevPathFromTextUsbAudio
},
2402 {L
"UsbCDCControl", DevPathFromTextUsbCDCControl
},
2403 {L
"UsbHID", DevPathFromTextUsbHID
},
2404 {L
"UsbImage", DevPathFromTextUsbImage
},
2405 {L
"UsbPrinter", DevPathFromTextUsbPrinter
},
2406 {L
"UsbMassStorage", DevPathFromTextUsbMassStorage
},
2407 {L
"UsbHub", DevPathFromTextUsbHub
},
2408 {L
"UsbCDCData", DevPathFromTextUsbCDCData
},
2409 {L
"UsbSmartCard", DevPathFromTextUsbSmartCard
},
2410 {L
"UsbVideo", DevPathFromTextUsbVideo
},
2411 {L
"UsbDiagnostic", DevPathFromTextUsbDiagnostic
},
2412 {L
"UsbWireless", DevPathFromTextUsbWireless
},
2413 {L
"UsbDeviceFirmwareUpdate", DevPathFromTextUsbDeviceFirmwareUpdate
},
2414 {L
"UsbIrdaBridge", DevPathFromTextUsbIrdaBridge
},
2415 {L
"UsbTestAndMeasurement", DevPathFromTextUsbTestAndMeasurement
},
2416 {L
"UsbWwid", DevPathFromTextUsbWwid
},
2417 {L
"Unit", DevPathFromTextUnit
},
2418 {L
"iSCSI", DevPathFromTextiSCSI
},
2419 {L
"HD", DevPathFromTextHD
},
2420 {L
"CDROM", DevPathFromTextCDROM
},
2421 {L
"VenMEDIA", DevPathFromTextVenMEDIA
},
2422 {L
"Media", DevPathFromTextMedia
},
2423 {L
"Fv", DevPathFromTextFv
},
2424 {L
"FvFile", DevPathFromTextFvFile
},
2425 {L
"BBS", DevPathFromTextBBS
},
2426 {L
"Sata", DevPathFromTextSata
},
2430 EFI_DEVICE_PATH_PROTOCOL
*
2431 ConvertTextToDeviceNode (
2432 IN CONST CHAR16
*TextDeviceNode
2436 Routine Description:
2437 Convert text to the binary representation of a device node.
2440 TextDeviceNode - TextDeviceNode points to the text representation of a device
2441 node. Conversion starts with the first character and continues
2442 until the first non-device node character.
2445 A pointer - Pointer to the EFI device node.
2446 NULL - If TextDeviceNode is NULL or there was insufficient memory or text unsupported.
2450 EFI_DEVICE_PATH_PROTOCOL
* (*DumpNode
) (CHAR16
*);
2452 EFI_DEVICE_PATH_PROTOCOL
*DeviceNode
;
2453 CHAR16
*DeviceNodeStr
;
2456 if ((TextDeviceNode
== NULL
) || (IS_NULL (*TextDeviceNode
))) {
2462 DeviceNodeStr
= StrDuplicate (TextDeviceNode
);
2464 for (Index
= 0; DevPathFromTextTable
[Index
].Function
; Index
++) {
2465 ParamStr
= GetParamByNodeName (DeviceNodeStr
, DevPathFromTextTable
[Index
].DevicePathNodeText
);
2466 if (ParamStr
!= NULL
) {
2467 DumpNode
= DevPathFromTextTable
[Index
].Function
;
2472 if (DumpNode
== NULL
) {
2476 DumpNode
= DevPathFromTextFilePath
;
2477 DeviceNode
= DumpNode (DeviceNodeStr
);
2479 DeviceNode
= DumpNode (ParamStr
);
2480 FreePool (ParamStr
);
2483 FreePool (DeviceNodeStr
);
2488 EFI_DEVICE_PATH_PROTOCOL
*
2489 ConvertTextToDevicePath (
2490 IN CONST CHAR16
*TextDevicePath
2494 Routine Description:
2495 Convert text to the binary representation of a device path.
2498 TextDevicePath - TextDevicePath points to the text representation of a device
2499 path. Conversion starts with the first character and continues
2500 until the first non-device node character.
2503 A pointer - Pointer to the allocated device path.
2504 NULL - If TextDeviceNode is NULL or there was insufficient memory.
2508 EFI_DEVICE_PATH_PROTOCOL
* (*DumpNode
) (CHAR16
*);
2510 EFI_DEVICE_PATH_PROTOCOL
*DeviceNode
;
2512 EFI_DEVICE_PATH_PROTOCOL
*NewDevicePath
;
2513 CHAR16
*DevicePathStr
;
2515 CHAR16
*DeviceNodeStr
;
2516 UINT8 IsInstanceEnd
;
2517 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
2519 if ((TextDevicePath
== NULL
) || (IS_NULL (*TextDevicePath
))) {
2523 DevicePath
= (EFI_DEVICE_PATH_PROTOCOL
*) AllocatePool (END_DEVICE_PATH_LENGTH
);
2524 SetDevicePathEndNode (DevicePath
);
2527 DeviceNodeStr
= NULL
;
2528 DevicePathStr
= StrDuplicate (TextDevicePath
);
2530 Str
= DevicePathStr
;
2531 while ((DeviceNodeStr
= GetNextDeviceNodeStr (&Str
, &IsInstanceEnd
)) != NULL
) {
2533 for (Index
= 0; DevPathFromTextTable
[Index
].Function
; Index
++) {
2534 ParamStr
= GetParamByNodeName (DeviceNodeStr
, DevPathFromTextTable
[Index
].DevicePathNodeText
);
2535 if (ParamStr
!= NULL
) {
2536 DumpNode
= DevPathFromTextTable
[Index
].Function
;
2541 if (DumpNode
== NULL
) {
2545 DumpNode
= DevPathFromTextFilePath
;
2546 DeviceNode
= DumpNode (DeviceNodeStr
);
2548 DeviceNode
= DumpNode (ParamStr
);
2549 FreePool (ParamStr
);
2552 NewDevicePath
= AppendDeviceNodeProtocolInterface (DevicePath
, DeviceNode
);
2553 FreePool (DevicePath
);
2554 FreePool (DeviceNode
);
2555 DevicePath
= NewDevicePath
;
2557 if (IsInstanceEnd
) {
2558 DeviceNode
= (EFI_DEVICE_PATH_PROTOCOL
*) AllocatePool (END_DEVICE_PATH_LENGTH
);
2559 SetDevicePathInstanceEndNode (DeviceNode
);
2561 NewDevicePath
= AppendDeviceNodeProtocolInterface (DevicePath
, DeviceNode
);
2562 FreePool (DevicePath
);
2563 FreePool (DeviceNode
);
2564 DevicePath
= NewDevicePath
;
2568 FreePool (DevicePathStr
);