3 Copyright (c) 2006, Intel Corporation
4 All rights reserved. This program and the accompanying materials
5 are licensed and made available under the terms and conditions of the BSD License
6 which accompanies this distribution. The full text of the license may be found at
7 http://opensource.org/licenses/bsd-license.php
9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
18 DevicePathFromText protocol as defined in the UEFI 2.0 specification.
22 #include "DevicePath.h"
45 Length
= StrLen ((CHAR16
*) Src
);
47 ReturnStr
= AllocateCopyPool ((Length
+ 1) * sizeof (CHAR16
), (VOID
*) Src
);
61 Get parameter in a pair of parentheses follow the given node name.
62 For example, given the "Pci(0,1)" and NodeName "Pci", it returns "0,1".
65 Str - Device Path Text
66 NodeName - Name of the node
69 Parameter text for the node
76 UINTN ParameterLength
;
79 // Check whether the node name matchs
81 NodeNameLength
= StrLen (NodeName
);
82 if (CompareMem (Str
, NodeName
, NodeNameLength
* sizeof (CHAR16
)) != 0) {
86 ParamStr
= Str
+ NodeNameLength
;
87 if (!IS_LEFT_PARENTH (*ParamStr
)) {
92 // Skip the found '(' and find first occurrence of ')'
96 StrPointer
= ParamStr
;
97 while (!IS_NULL (*StrPointer
)) {
98 if (IS_RIGHT_PARENTH (*StrPointer
)) {
104 if (IS_NULL (*StrPointer
)) {
111 ParamStr
= AllocateCopyPool ((ParameterLength
+ 1) * sizeof (CHAR16
), ParamStr
);
112 if (ParamStr
== NULL
) {
116 // Terminate the parameter string
118 ParamStr
[ParameterLength
] = L
'\0';
126 IN OUT CHAR16
**List
,
132 Get current sub-string from a string list, before return
133 the list header is moved to next sub-string. The sub-string is separated
134 by the specified character. For example, the separator is ',', the string
135 list is "2,0,3", it returns "2", the remain list move to "0,3"
138 List - A string list separated by the specified separator
139 Separator - The separator character
142 pointer - The current sub-string
152 if (IS_NULL (*Str
)) {
157 // Find first occurrence of the separator
159 while (!IS_NULL (*Str
)) {
160 if (*Str
== Separator
) {
166 if (*Str
== Separator
) {
168 // Find a sub-string, terminate it
175 // Move to next sub-string
189 // The separator is comma
191 return SplitStr (List
, L
',');
196 GetNextDeviceNodeStr (
197 IN OUT CHAR16
**DevicePath
,
198 OUT BOOLEAN
*IsInstanceEnd
203 Get one device node from entire device path text.
206 Str - The entire device path text string
207 IsInstanceEnd - This node is the end of a device path instance
210 a pointer - A device node text
211 NULL - No more device node available
217 UINTN ParenthesesStack
;
220 if (IS_NULL (*Str
)) {
225 // Skip the leading '/', '(', ')' and ','
227 while (!IS_NULL (*Str
)) {
228 if (!IS_SLASH (*Str
) &&
230 !IS_LEFT_PARENTH (*Str
) &&
231 !IS_RIGHT_PARENTH (*Str
)) {
240 // Scan for the separator of this device node, '/' or ','
242 ParenthesesStack
= 0;
243 while (!IS_NULL (*Str
)) {
244 if ((IS_COMMA (*Str
) || IS_SLASH (*Str
)) && (ParenthesesStack
== 0)) {
248 if (IS_LEFT_PARENTH (*Str
)) {
250 } else if (IS_RIGHT_PARENTH (*Str
)) {
257 if (ParenthesesStack
!= 0) {
259 // The '(' doesn't pair with ')', invalid device path text
264 if (IS_COMMA (*Str
)) {
265 *IsInstanceEnd
= TRUE
;
269 *IsInstanceEnd
= FALSE
;
270 if (!IS_NULL (*Str
)) {
290 Determines if a Unicode character is a hexadecimal digit.
291 The test is case insensitive.
294 Digit - Pointer to byte that receives the value of the hex character.
295 Char - Unicode character to test.
298 TRUE - If the character is a hexadecimal digit.
303 if ((Char
>= L
'0') && (Char
<= L
'9')) {
304 *Digit
= (UINT8
) (Char
- L
'0');
308 if ((Char
>= L
'A') && (Char
<= L
'F')) {
309 *Digit
= (UINT8
) (Char
- L
'A' + 0x0A);
313 if ((Char
>= L
'a') && (Char
<= L
'f')) {
314 *Digit
= (UINT8
) (Char
- L
'a' + 0x0A);
327 OUT UINTN
*ConvertedStrLen OPTIONAL
332 Converts Unicode string to binary buffer.
333 The conversion may be partial.
334 The first character in the string that is not hex digit stops the conversion.
335 At a minimum, any blob of data could be represented as a hex string.
338 Buf - Pointer to buffer that receives the data.
339 Len - Length in bytes of the buffer to hold converted data.
340 If routine return with EFI_SUCCESS, containing length of converted data.
341 If routine return with EFI_BUFFER_TOO_SMALL, containg length of buffer desired.
342 Str - String to be converted from.
343 ConvertedStrLen - Length of the Hex String consumed.
346 EFI_SUCCESS: Routine Success.
347 EFI_BUFFER_TOO_SMALL: The buffer is too small to hold converted data.
361 // Find out how many hex characters the string has.
363 for (Idx
= 0, HexCnt
= 0; IsHexDigit (&Digit
, Str
[Idx
]); Idx
++, HexCnt
++);
370 // Two Unicode characters make up 1 buffer byte. Round up.
372 BufferLength
= (HexCnt
+ 1) / 2;
375 // Test if buffer is passed enough.
377 if (BufferLength
> (*Len
)) {
379 return EFI_BUFFER_TOO_SMALL
;
384 for (Idx
= 0; Idx
< HexCnt
; Idx
++) {
386 IsHexDigit (&Digit
, Str
[HexCnt
- 1 - Idx
]);
389 // For odd charaters, write the lower nibble for each buffer byte,
390 // and for even characters, the upper nibble.
392 if ((Idx
& 1) == 0) {
397 Byte
= (UINT8
) (Byte
| Digit
<< 4);
403 if (ConvertedStrLen
!= NULL
) {
404 *ConvertedStrLen
= HexCnt
;
419 Skip the leading white space and '0x' or '0X' of a integer string
422 Str - The integer string
423 IsHex - 1: Hex string, 0: Decimal string
432 // skip preceeding white space
434 while (*Str
&& *Str
== ' ') {
438 // skip preceeding zeros
440 while (*Str
&& *Str
== '0') {
444 // skip preceeding character 'x' or 'X'
446 if (*Str
&& (*Str
== 'x' || *Str
== 'X')) {
463 Convert hex string to uint
476 ASSERT (Str
!= NULL
);
479 // convert hex digits
482 Length
= sizeof (UINTN
);
483 HexStringToBuf ((UINT8
*) &Rvalue
, &Length
, Str
, NULL
);
498 Convert hex string to 64 bit data.
511 Length
= sizeof (UINT64
);
512 HexStringToBuf ((UINT8
*) Data
, &Length
, Str
, NULL
);
524 Convert decimal string to uint
539 ASSERT (str
!= NULL
);
541 High
= (UINTN
) -1 / 10;
542 Low
= (UINTN
) -1 % 10;
544 // skip preceeding white space
546 while (*str
&& *str
== ' ') {
555 if (Char
>= '0' && Char
<= '9') {
556 if ((Rvalue
> High
|| Rvalue
== High
) && (Char
- '0' > (INTN
) Low
)) {
560 Rvalue
= (Rvalue
* 10) + Char
- '0';
581 Convert decimal string to uint
596 ASSERT (str
!= NULL
);
597 ASSERT (Data
!= NULL
);
600 // skip preceeding white space
602 while (*str
&& *str
== ' ') {
611 if (Char
>= '0' && Char
<= '9') {
612 High
= LShiftU64 (Rvalue
, 3);
613 Low
= LShiftU64 (Rvalue
, 1);
614 Rvalue
= High
+ Low
+ Char
- '0';
634 Convert integer string to uint.
638 Str - The integer string. If leading with "0x" or "0X", it's heximal.
646 Str
= TrimHexStr (Str
, &IsHex
);
665 Convert integer string to 64 bit data.
669 Str - The integer string. If leading with "0x" or "0X", it's heximal.
677 Str
= TrimHexStr (Str
, &IsHex
);
690 IN UINTN BufferLength
,
702 // Two hex char make up one byte
704 StrLength
= BufferLength
* sizeof (CHAR16
);
706 for(Index
= 0; Index
< StrLength
; Index
++, Str
++) {
708 IsHexDigit (&Digit
, *Str
);
711 // For odd charaters, write the upper nibble for each buffer byte,
712 // and for even characters, the lower nibble.
714 if ((Index
& 1) == 0) {
715 Byte
= (UINT8
) (Digit
<< 4);
717 Byte
= Buf
[Index
/ 2];
719 Byte
= (UINT8
) (Byte
| Digit
);
722 Buf
[Index
/ 2] = Byte
;
736 UINTN ConvertedStrLen
;
739 BufferLength
= sizeof (Guid
->Data1
);
740 Status
= HexStringToBuf ((UINT8
*) &Guid
->Data1
, &BufferLength
, Str
, &ConvertedStrLen
);
741 if (EFI_ERROR (Status
)) {
744 Str
+= ConvertedStrLen
;
745 if (IS_HYPHEN (*Str
)) {
748 return EFI_UNSUPPORTED
;
751 BufferLength
= sizeof (Guid
->Data2
);
752 Status
= HexStringToBuf ((UINT8
*) &Guid
->Data2
, &BufferLength
, Str
, &ConvertedStrLen
);
753 if (EFI_ERROR (Status
)) {
756 Str
+= ConvertedStrLen
;
757 if (IS_HYPHEN (*Str
)) {
760 return EFI_UNSUPPORTED
;
763 BufferLength
= sizeof (Guid
->Data3
);
764 Status
= HexStringToBuf ((UINT8
*) &Guid
->Data3
, &BufferLength
, Str
, &ConvertedStrLen
);
765 if (EFI_ERROR (Status
)) {
768 Str
+= ConvertedStrLen
;
769 if (IS_HYPHEN (*Str
)) {
772 return EFI_UNSUPPORTED
;
775 StrToBuf (&Guid
->Data4
[0], 2, Str
);
777 // Skip 2 byte hex chars
781 if (IS_HYPHEN (*Str
)) {
784 return EFI_UNSUPPORTED
;
786 StrToBuf (&Guid
->Data4
[2], 6, Str
);
795 OUT EFI_IPv4_ADDRESS
*IPv4Addr
800 for (Index
= 0; Index
< 4; Index
++) {
801 IPv4Addr
->Addr
[Index
] = (UINT8
) Dtoi (SplitStr (Str
, L
'.'));
809 OUT EFI_IPv6_ADDRESS
*IPv6Addr
815 for (Index
= 0; Index
< 8; Index
++) {
816 Data
= (UINT16
) Xtoi (SplitStr (Str
, L
':'));
817 IPv6Addr
->Addr
[Index
* 2] = (UINT8
) (Data
>> 8);
818 IPv6Addr
->Addr
[Index
* 2 + 1] = (UINT8
) (Data
& 0xff);
826 IN OUT CHAR8
**AsciiStr
832 while (!IS_NULL (*Str
)) {
833 *(Dest
++) = (CHAR8
) *(Str
++);
838 // Return the string next to it
840 *AsciiStr
= Dest
+ 1;
844 EFI_DEVICE_PATH_PROTOCOL
*
846 IN CHAR16
*TextDeviceNode
851 PCI_DEVICE_PATH
*Pci
;
853 DeviceStr
= GetNextParamStr (&TextDeviceNode
);
854 FunctionStr
= GetNextParamStr (&TextDeviceNode
);
855 Pci
= (PCI_DEVICE_PATH
*) CreateDeviceNode (
856 HARDWARE_DEVICE_PATH
,
858 sizeof (PCI_DEVICE_PATH
)
861 Pci
->Function
= (UINT8
) Strtoi (FunctionStr
);
862 Pci
->Device
= (UINT8
) Strtoi (DeviceStr
);
864 return (EFI_DEVICE_PATH_PROTOCOL
*) Pci
;
868 EFI_DEVICE_PATH_PROTOCOL
*
869 DevPathFromTextPcCard (
870 IN CHAR16
*TextDeviceNode
873 CHAR16
*FunctionNumberStr
;
874 PCCARD_DEVICE_PATH
*Pccard
;
876 FunctionNumberStr
= GetNextParamStr (&TextDeviceNode
);
877 Pccard
= (PCCARD_DEVICE_PATH
*) CreateDeviceNode (
878 HARDWARE_DEVICE_PATH
,
880 sizeof (PCCARD_DEVICE_PATH
)
883 Pccard
->FunctionNumber
= (UINT8
) Strtoi (FunctionNumberStr
);
885 return (EFI_DEVICE_PATH_PROTOCOL
*) Pccard
;
889 EFI_DEVICE_PATH_PROTOCOL
*
890 DevPathFromTextMemoryMapped (
891 IN CHAR16
*TextDeviceNode
894 CHAR16
*MemoryTypeStr
;
895 CHAR16
*StartingAddressStr
;
896 CHAR16
*EndingAddressStr
;
897 MEMMAP_DEVICE_PATH
*MemMap
;
899 MemoryTypeStr
= GetNextParamStr (&TextDeviceNode
);
900 StartingAddressStr
= GetNextParamStr (&TextDeviceNode
);
901 EndingAddressStr
= GetNextParamStr (&TextDeviceNode
);
902 MemMap
= (MEMMAP_DEVICE_PATH
*) CreateDeviceNode (
903 HARDWARE_DEVICE_PATH
,
905 sizeof (MEMMAP_DEVICE_PATH
)
908 MemMap
->MemoryType
= (UINT32
) Strtoi (MemoryTypeStr
);
909 Strtoi64 (StartingAddressStr
, &MemMap
->StartingAddress
);
910 Strtoi64 (EndingAddressStr
, &MemMap
->EndingAddress
);
912 return (EFI_DEVICE_PATH_PROTOCOL
*) MemMap
;
916 EFI_DEVICE_PATH_PROTOCOL
*
917 ConvertFromTextVendor (
918 IN CHAR16
*TextDeviceNode
,
926 VENDOR_DEVICE_PATH
*Vendor
;
928 GuidStr
= GetNextParamStr (&TextDeviceNode
);
930 DataStr
= GetNextParamStr (&TextDeviceNode
);
931 Length
= StrLen (DataStr
);
933 // Two hex characters make up 1 buffer byte
935 Length
= (Length
+ 1) / 2;
937 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
940 (UINT16
) (sizeof (VENDOR_DEVICE_PATH
) + Length
)
943 StrToGuid (GuidStr
, &Vendor
->Guid
);
944 StrToBuf (((UINT8
*) Vendor
) + sizeof (VENDOR_DEVICE_PATH
), Length
, DataStr
);
946 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
950 EFI_DEVICE_PATH_PROTOCOL
*
951 DevPathFromTextVenHw (
952 IN CHAR16
*TextDeviceNode
955 return ConvertFromTextVendor (
957 HARDWARE_DEVICE_PATH
,
963 EFI_DEVICE_PATH_PROTOCOL
*
964 DevPathFromTextCtrl (
965 IN CHAR16
*TextDeviceNode
968 CHAR16
*ControllerStr
;
969 CONTROLLER_DEVICE_PATH
*Controller
;
971 ControllerStr
= GetNextParamStr (&TextDeviceNode
);
972 Controller
= (CONTROLLER_DEVICE_PATH
*) CreateDeviceNode (
973 HARDWARE_DEVICE_PATH
,
975 sizeof (CONTROLLER_DEVICE_PATH
)
977 Controller
->ControllerNumber
= (UINT32
) Strtoi (ControllerStr
);
979 return (EFI_DEVICE_PATH_PROTOCOL
*) Controller
;
991 PnpId
= Xtoi (Text
+ 3);
992 *EisaId
= (((Text
[0] - '@') & 0x1f) << 10) +
993 (((Text
[1] - '@') & 0x1f) << 5) +
994 ((Text
[2] - '@') & 0x1f) +
995 (UINT32
) (PnpId
<< 16);
998 EFI_DEVICE_PATH_PROTOCOL
*
999 DevPathFromTextAcpi (
1000 IN CHAR16
*TextDeviceNode
1005 ACPI_HID_DEVICE_PATH
*Acpi
;
1007 HIDStr
= GetNextParamStr (&TextDeviceNode
);
1008 UIDStr
= GetNextParamStr (&TextDeviceNode
);
1009 Acpi
= (ACPI_HID_DEVICE_PATH
*) CreateDeviceNode (
1012 sizeof (ACPI_HID_DEVICE_PATH
)
1015 EisaIdFromText (HIDStr
, &Acpi
->HID
);
1016 Acpi
->UID
= (UINT32
) Strtoi (UIDStr
);
1018 return (EFI_DEVICE_PATH_PROTOCOL
*) Acpi
;
1022 EFI_DEVICE_PATH_PROTOCOL
*
1023 ConvertFromTextAcpi (
1024 IN CHAR16
*TextDeviceNode
,
1029 ACPI_HID_DEVICE_PATH
*Acpi
;
1031 UIDStr
= GetNextParamStr (&TextDeviceNode
);
1032 Acpi
= (ACPI_HID_DEVICE_PATH
*) CreateDeviceNode (
1035 sizeof (ACPI_HID_DEVICE_PATH
)
1038 Acpi
->HID
= EFI_PNP_ID (PnPId
);
1039 Acpi
->UID
= (UINT32
) Strtoi (UIDStr
);
1041 return (EFI_DEVICE_PATH_PROTOCOL
*) Acpi
;
1045 EFI_DEVICE_PATH_PROTOCOL
*
1046 DevPathFromTextPciRoot (
1047 IN CHAR16
*TextDeviceNode
1050 return ConvertFromTextAcpi (TextDeviceNode
, 0x0a03);
1054 EFI_DEVICE_PATH_PROTOCOL
*
1055 DevPathFromTextFloppy (
1056 IN CHAR16
*TextDeviceNode
1059 return ConvertFromTextAcpi (TextDeviceNode
, 0x0604);
1063 EFI_DEVICE_PATH_PROTOCOL
*
1064 DevPathFromTextKeyboard (
1065 IN CHAR16
*TextDeviceNode
1068 return ConvertFromTextAcpi (TextDeviceNode
, 0x0301);
1072 EFI_DEVICE_PATH_PROTOCOL
*
1073 DevPathFromTextSerial (
1074 IN CHAR16
*TextDeviceNode
1077 return ConvertFromTextAcpi (TextDeviceNode
, 0x0501);
1081 EFI_DEVICE_PATH_PROTOCOL
*
1082 DevPathFromTextParallelPort (
1083 IN CHAR16
*TextDeviceNode
1086 return ConvertFromTextAcpi (TextDeviceNode
, 0x0401);
1090 EFI_DEVICE_PATH_PROTOCOL
*
1091 DevPathFromTextAcpiEx (
1092 IN CHAR16
*TextDeviceNode
1103 ACPI_EXTENDED_HID_DEVICE_PATH
*AcpiEx
;
1105 HIDStr
= GetNextParamStr (&TextDeviceNode
);
1106 CIDStr
= GetNextParamStr (&TextDeviceNode
);
1107 UIDStr
= GetNextParamStr (&TextDeviceNode
);
1108 HIDSTRStr
= GetNextParamStr (&TextDeviceNode
);
1109 CIDSTRStr
= GetNextParamStr (&TextDeviceNode
);
1110 UIDSTRStr
= GetNextParamStr (&TextDeviceNode
);
1112 Length
= (UINT16
) (sizeof (ACPI_EXTENDED_HID_DEVICE_PATH
) + StrLen (HIDSTRStr
) + 1);
1113 Length
= (UINT16
) (Length
+ StrLen (UIDSTRStr
) + 1);
1114 Length
= (UINT16
) (Length
+ StrLen (CIDSTRStr
) + 1);
1115 AcpiEx
= (ACPI_EXTENDED_HID_DEVICE_PATH
*) CreateDeviceNode (
1121 EisaIdFromText (HIDStr
, &AcpiEx
->HID
);
1122 EisaIdFromText (CIDStr
, &AcpiEx
->CID
);
1123 AcpiEx
->UID
= (UINT32
) Strtoi (UIDStr
);
1125 AsciiStr
= (CHAR8
*) ((UINT8
*)AcpiEx
+ sizeof (ACPI_EXTENDED_HID_DEVICE_PATH
));
1126 StrToAscii (HIDSTRStr
, &AsciiStr
);
1127 StrToAscii (UIDSTRStr
, &AsciiStr
);
1128 StrToAscii (CIDSTRStr
, &AsciiStr
);
1130 return (EFI_DEVICE_PATH_PROTOCOL
*) AcpiEx
;
1134 EFI_DEVICE_PATH_PROTOCOL
*
1135 DevPathFromTextAcpiExp (
1136 IN CHAR16
*TextDeviceNode
1144 ACPI_EXTENDED_HID_DEVICE_PATH
*AcpiEx
;
1146 HIDStr
= GetNextParamStr (&TextDeviceNode
);
1147 CIDStr
= GetNextParamStr (&TextDeviceNode
);
1148 UIDSTRStr
= GetNextParamStr (&TextDeviceNode
);
1149 Length
= (UINT16
) (sizeof (ACPI_EXTENDED_HID_DEVICE_PATH
) + StrLen (UIDSTRStr
) + 3);
1150 AcpiEx
= (ACPI_EXTENDED_HID_DEVICE_PATH
*) CreateDeviceNode (
1156 EisaIdFromText (HIDStr
, &AcpiEx
->HID
);
1157 EisaIdFromText (CIDStr
, &AcpiEx
->CID
);
1160 AsciiStr
= (CHAR8
*) ((UINT8
*)AcpiEx
+ sizeof (ACPI_EXTENDED_HID_DEVICE_PATH
));
1162 // HID string is NULL
1166 // Convert UID string
1169 StrToAscii (UIDSTRStr
, &AsciiStr
);
1171 // CID string is NULL
1175 return (EFI_DEVICE_PATH_PROTOCOL
*) AcpiEx
;
1179 EFI_DEVICE_PATH_PROTOCOL
*
1180 DevPathFromTextAta (
1181 IN CHAR16
*TextDeviceNode
1184 CHAR16
*PrimarySecondaryStr
;
1185 CHAR16
*SlaveMasterStr
;
1187 ATAPI_DEVICE_PATH
*Atapi
;
1189 Atapi
= (ATAPI_DEVICE_PATH
*) CreateDeviceNode (
1190 MESSAGING_DEVICE_PATH
,
1192 sizeof (ATAPI_DEVICE_PATH
)
1195 PrimarySecondaryStr
= GetNextParamStr (&TextDeviceNode
);
1196 SlaveMasterStr
= GetNextParamStr (&TextDeviceNode
);
1197 LunStr
= GetNextParamStr (&TextDeviceNode
);
1199 Atapi
->PrimarySecondary
= (UINT8
) ((StrCmp (PrimarySecondaryStr
, L
"Primary") == 0) ? 0 : 1);
1200 Atapi
->SlaveMaster
= (UINT8
) ((StrCmp (SlaveMasterStr
, L
"Master") == 0) ? 0 : 1);
1201 Atapi
->Lun
= (UINT16
) Strtoi (LunStr
);
1203 return (EFI_DEVICE_PATH_PROTOCOL
*) Atapi
;
1207 EFI_DEVICE_PATH_PROTOCOL
*
1208 DevPathFromTextScsi (
1209 IN CHAR16
*TextDeviceNode
1214 SCSI_DEVICE_PATH
*Scsi
;
1216 PunStr
= GetNextParamStr (&TextDeviceNode
);
1217 LunStr
= GetNextParamStr (&TextDeviceNode
);
1218 Scsi
= (SCSI_DEVICE_PATH
*) CreateDeviceNode (
1219 MESSAGING_DEVICE_PATH
,
1221 sizeof (SCSI_DEVICE_PATH
)
1224 Scsi
->Pun
= (UINT16
) Strtoi (PunStr
);
1225 Scsi
->Lun
= (UINT16
) Strtoi (LunStr
);
1227 return (EFI_DEVICE_PATH_PROTOCOL
*) Scsi
;
1231 EFI_DEVICE_PATH_PROTOCOL
*
1232 DevPathFromTextFibre (
1233 IN CHAR16
*TextDeviceNode
1238 FIBRECHANNEL_DEVICE_PATH
*Fibre
;
1240 WWNStr
= GetNextParamStr (&TextDeviceNode
);
1241 LunStr
= GetNextParamStr (&TextDeviceNode
);
1242 Fibre
= (FIBRECHANNEL_DEVICE_PATH
*) CreateDeviceNode (
1243 MESSAGING_DEVICE_PATH
,
1244 MSG_FIBRECHANNEL_DP
,
1245 sizeof (FIBRECHANNEL_DEVICE_PATH
)
1248 Fibre
->Reserved
= 0;
1249 Strtoi64 (WWNStr
, &Fibre
->WWN
);
1250 Strtoi64 (LunStr
, &Fibre
->Lun
);
1252 return (EFI_DEVICE_PATH_PROTOCOL
*) Fibre
;
1256 EFI_DEVICE_PATH_PROTOCOL
*
1257 DevPathFromText1394 (
1258 IN CHAR16
*TextDeviceNode
1262 F1394_DEVICE_PATH
*F1394
;
1264 GuidStr
= GetNextParamStr (&TextDeviceNode
);
1265 F1394
= (F1394_DEVICE_PATH
*) CreateDeviceNode (
1266 MESSAGING_DEVICE_PATH
,
1268 sizeof (F1394_DEVICE_PATH
)
1271 F1394
->Reserved
= 0;
1272 Xtoi64 (GuidStr
, &F1394
->Guid
);
1274 return (EFI_DEVICE_PATH_PROTOCOL
*) F1394
;
1278 EFI_DEVICE_PATH_PROTOCOL
*
1279 DevPathFromTextUsb (
1280 IN CHAR16
*TextDeviceNode
1284 CHAR16
*InterfaceStr
;
1285 USB_DEVICE_PATH
*Usb
;
1287 PortStr
= GetNextParamStr (&TextDeviceNode
);
1288 InterfaceStr
= GetNextParamStr (&TextDeviceNode
);
1289 Usb
= (USB_DEVICE_PATH
*) CreateDeviceNode (
1290 MESSAGING_DEVICE_PATH
,
1292 sizeof (USB_DEVICE_PATH
)
1295 Usb
->ParentPortNumber
= (UINT8
) Strtoi (PortStr
);
1296 Usb
->InterfaceNumber
= (UINT8
) Strtoi (InterfaceStr
);
1298 return (EFI_DEVICE_PATH_PROTOCOL
*) Usb
;
1302 EFI_DEVICE_PATH_PROTOCOL
*
1303 DevPathFromTextI2O (
1304 IN CHAR16
*TextDeviceNode
1308 I2O_DEVICE_PATH
*I2O
;
1310 TIDStr
= GetNextParamStr (&TextDeviceNode
);
1311 I2O
= (I2O_DEVICE_PATH
*) CreateDeviceNode (
1312 MESSAGING_DEVICE_PATH
,
1314 sizeof (I2O_DEVICE_PATH
)
1317 I2O
->Tid
= (UINT32
) Strtoi (TIDStr
);
1319 return (EFI_DEVICE_PATH_PROTOCOL
*) I2O
;
1323 EFI_DEVICE_PATH_PROTOCOL
*
1324 DevPathFromTextInfiniband (
1325 IN CHAR16
*TextDeviceNode
1334 INFINIBAND_DEVICE_PATH
*InfiniBand
;
1336 FlagsStr
= GetNextParamStr (&TextDeviceNode
);
1337 GuidStr
= GetNextParamStr (&TextDeviceNode
);
1338 SidStr
= GetNextParamStr (&TextDeviceNode
);
1339 TidStr
= GetNextParamStr (&TextDeviceNode
);
1340 DidStr
= GetNextParamStr (&TextDeviceNode
);
1341 InfiniBand
= (INFINIBAND_DEVICE_PATH
*) CreateDeviceNode (
1342 MESSAGING_DEVICE_PATH
,
1344 sizeof (INFINIBAND_DEVICE_PATH
)
1347 InfiniBand
->ResourceFlags
= (UINT32
) Strtoi (FlagsStr
);
1348 StrToGuid (GuidStr
, &PortGid
);
1349 CopyMem (InfiniBand
->PortGid
, &PortGid
, sizeof (EFI_GUID
));
1350 Strtoi64 (SidStr
, &InfiniBand
->ServiceId
);
1351 Strtoi64 (TidStr
, &InfiniBand
->TargetPortId
);
1352 Strtoi64 (DidStr
, &InfiniBand
->DeviceId
);
1354 return (EFI_DEVICE_PATH_PROTOCOL
*) InfiniBand
;
1358 EFI_DEVICE_PATH_PROTOCOL
*
1359 DevPathFromTextVenMsg (
1360 IN CHAR16
*TextDeviceNode
1363 return ConvertFromTextVendor (
1365 MESSAGING_DEVICE_PATH
,
1371 EFI_DEVICE_PATH_PROTOCOL
*
1372 DevPathFromTextVenPcAnsi (
1373 IN CHAR16
*TextDeviceNode
1376 VENDOR_DEVICE_PATH
*Vendor
;
1378 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
1379 MESSAGING_DEVICE_PATH
,
1381 sizeof (VENDOR_DEVICE_PATH
));
1382 CopyGuid (&Vendor
->Guid
, &gEfiPcAnsiGuid
);
1384 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
1388 EFI_DEVICE_PATH_PROTOCOL
*
1389 DevPathFromTextVenVt100 (
1390 IN CHAR16
*TextDeviceNode
1393 VENDOR_DEVICE_PATH
*Vendor
;
1395 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
1396 MESSAGING_DEVICE_PATH
,
1398 sizeof (VENDOR_DEVICE_PATH
));
1399 CopyGuid (&Vendor
->Guid
, &gEfiVT100Guid
);
1401 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
1405 EFI_DEVICE_PATH_PROTOCOL
*
1406 DevPathFromTextVenVt100Plus (
1407 IN CHAR16
*TextDeviceNode
1410 VENDOR_DEVICE_PATH
*Vendor
;
1412 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
1413 MESSAGING_DEVICE_PATH
,
1415 sizeof (VENDOR_DEVICE_PATH
));
1416 CopyGuid (&Vendor
->Guid
, &gEfiVT100PlusGuid
);
1418 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
1422 EFI_DEVICE_PATH_PROTOCOL
*
1423 DevPathFromTextVenUtf8 (
1424 IN CHAR16
*TextDeviceNode
1427 VENDOR_DEVICE_PATH
*Vendor
;
1429 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
1430 MESSAGING_DEVICE_PATH
,
1432 sizeof (VENDOR_DEVICE_PATH
));
1433 CopyGuid (&Vendor
->Guid
, &gEfiVTUTF8Guid
);
1435 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
1439 EFI_DEVICE_PATH_PROTOCOL
*
1440 DevPathFromTextUartFlowCtrl (
1441 IN CHAR16
*TextDeviceNode
1445 UART_FLOW_CONTROL_DEVICE_PATH
*UartFlowControl
;
1447 ValueStr
= GetNextParamStr (&TextDeviceNode
);
1448 UartFlowControl
= (UART_FLOW_CONTROL_DEVICE_PATH
*) CreateDeviceNode (
1449 MESSAGING_DEVICE_PATH
,
1451 sizeof (UART_FLOW_CONTROL_DEVICE_PATH
)
1454 CopyGuid (&UartFlowControl
->Guid
, &mEfiDevicePathMessagingUartFlowControlGuid
);
1455 if (StrCmp (ValueStr
, L
"XonXoff") == 0) {
1456 UartFlowControl
->FlowControlMap
= 2;
1457 } else if (StrCmp (ValueStr
, L
"Hardware") == 0) {
1458 UartFlowControl
->FlowControlMap
= 1;
1460 UartFlowControl
->FlowControlMap
= 0;
1463 return (EFI_DEVICE_PATH_PROTOCOL
*) UartFlowControl
;
1467 EFI_DEVICE_PATH_PROTOCOL
*
1468 DevPathFromTextSAS (
1469 IN CHAR16
*TextDeviceNode
1476 CHAR16
*LocationStr
;
1478 CHAR16
*DriveBayStr
;
1479 CHAR16
*ReservedStr
;
1481 SAS_DEVICE_PATH
*Sas
;
1483 AddressStr
= GetNextParamStr (&TextDeviceNode
);
1484 LunStr
= GetNextParamStr (&TextDeviceNode
);
1485 RTPStr
= GetNextParamStr (&TextDeviceNode
);
1486 SASSATAStr
= GetNextParamStr (&TextDeviceNode
);
1487 LocationStr
= GetNextParamStr (&TextDeviceNode
);
1488 ConnectStr
= GetNextParamStr (&TextDeviceNode
);
1489 DriveBayStr
= GetNextParamStr (&TextDeviceNode
);
1490 ReservedStr
= GetNextParamStr (&TextDeviceNode
);
1492 Sas
= (SAS_DEVICE_PATH
*) CreateDeviceNode (
1493 MESSAGING_DEVICE_PATH
,
1495 sizeof (SAS_DEVICE_PATH
)
1498 CopyGuid (&Sas
->Guid
, &mEfiDevicePathMessagingSASGuid
);
1499 Strtoi64 (AddressStr
, &Sas
->SasAddress
);
1500 Strtoi64 (LunStr
, &Sas
->Lun
);
1501 Sas
->RelativeTargetPort
= (UINT16
) Strtoi (RTPStr
);
1502 if (StrCmp (SASSATAStr
, L
"NoTopology") != 0) {
1503 if (StrCmp (DriveBayStr
, L
"0") == 0) {
1507 Info
= (UINT16
) (Info
| (Strtoi (DriveBayStr
) << 8));
1510 if (StrCmp (SASSATAStr
, L
"SATA") == 0) {
1514 if (StrCmp (LocationStr
, L
"External") == 0) {
1518 if (StrCmp (ConnectStr
, L
"Expanded") == 0) {
1523 Sas
->DeviceTopology
= Info
;
1524 Sas
->Reserved
= (UINT32
) Strtoi (ReservedStr
);
1526 return (EFI_DEVICE_PATH_PROTOCOL
*) Sas
;
1530 EFI_DEVICE_PATH_PROTOCOL
*
1531 DevPathFromTextDebugPort (
1532 IN CHAR16
*TextDeviceNode
1535 VENDOR_DEFINED_MESSAGING_DEVICE_PATH
*Vend
;
1537 Vend
= (VENDOR_DEFINED_MESSAGING_DEVICE_PATH
*) CreateDeviceNode (
1538 MESSAGING_DEVICE_PATH
,
1540 sizeof (VENDOR_DEFINED_MESSAGING_DEVICE_PATH
)
1543 CopyGuid (&Vend
->Guid
, &gEfiDebugPortProtocolGuid
);
1545 return (EFI_DEVICE_PATH_PROTOCOL
*) Vend
;
1549 EFI_DEVICE_PATH_PROTOCOL
*
1550 DevPathFromTextMAC (
1551 IN CHAR16
*TextDeviceNode
1557 MAC_ADDR_DEVICE_PATH
*MAC
;
1559 AddressStr
= GetNextParamStr (&TextDeviceNode
);
1560 IfTypeStr
= GetNextParamStr (&TextDeviceNode
);
1561 MAC
= (MAC_ADDR_DEVICE_PATH
*) CreateDeviceNode (
1562 MESSAGING_DEVICE_PATH
,
1564 sizeof (MAC_ADDR_DEVICE_PATH
)
1567 MAC
->IfType
= (UINT8
) Strtoi (IfTypeStr
);
1569 Length
= sizeof (EFI_MAC_ADDRESS
);
1570 StrToBuf (&MAC
->MacAddress
.Addr
[0], Length
, AddressStr
);
1572 return (EFI_DEVICE_PATH_PROTOCOL
*) MAC
;
1576 EFI_DEVICE_PATH_PROTOCOL
*
1577 DevPathFromTextIPv4 (
1578 IN CHAR16
*TextDeviceNode
1581 CHAR16
*RemoteIPStr
;
1582 CHAR16
*ProtocolStr
;
1585 IPv4_DEVICE_PATH
*IPv4
;
1587 RemoteIPStr
= GetNextParamStr (&TextDeviceNode
);
1588 ProtocolStr
= GetNextParamStr (&TextDeviceNode
);
1589 TypeStr
= GetNextParamStr (&TextDeviceNode
);
1590 LocalIPStr
= GetNextParamStr (&TextDeviceNode
);
1591 IPv4
= (IPv4_DEVICE_PATH
*) CreateDeviceNode (
1592 MESSAGING_DEVICE_PATH
,
1594 sizeof (IPv4_DEVICE_PATH
)
1597 StrToIPv4Addr (&RemoteIPStr
, &IPv4
->RemoteIpAddress
);
1598 IPv4
->Protocol
= (UINT16
) ((StrCmp (ProtocolStr
, L
"UDP") == 0) ? 0 : 1);
1599 if (StrCmp (TypeStr
, L
"Static") == 0) {
1600 IPv4
->StaticIpAddress
= TRUE
;
1602 IPv4
->StaticIpAddress
= FALSE
;
1605 StrToIPv4Addr (&LocalIPStr
, &IPv4
->LocalIpAddress
);
1607 IPv4
->LocalPort
= 0;
1608 IPv4
->RemotePort
= 0;
1610 return (EFI_DEVICE_PATH_PROTOCOL
*) IPv4
;
1614 EFI_DEVICE_PATH_PROTOCOL
*
1615 DevPathFromTextIPv6 (
1616 IN CHAR16
*TextDeviceNode
1619 CHAR16
*RemoteIPStr
;
1620 CHAR16
*ProtocolStr
;
1623 IPv6_DEVICE_PATH
*IPv6
;
1625 RemoteIPStr
= GetNextParamStr (&TextDeviceNode
);
1626 ProtocolStr
= GetNextParamStr (&TextDeviceNode
);
1627 TypeStr
= GetNextParamStr (&TextDeviceNode
);
1628 LocalIPStr
= GetNextParamStr (&TextDeviceNode
);
1629 IPv6
= (IPv6_DEVICE_PATH
*) CreateDeviceNode (
1630 MESSAGING_DEVICE_PATH
,
1632 sizeof (IPv6_DEVICE_PATH
)
1635 StrToIPv6Addr (&RemoteIPStr
, &IPv6
->RemoteIpAddress
);
1636 IPv6
->Protocol
= (UINT16
) ((StrCmp (ProtocolStr
, L
"UDP") == 0) ? 0 : 1);
1637 if (StrCmp (TypeStr
, L
"Static") == 0) {
1638 IPv6
->StaticIpAddress
= TRUE
;
1640 IPv6
->StaticIpAddress
= FALSE
;
1643 StrToIPv6Addr (&LocalIPStr
, &IPv6
->LocalIpAddress
);
1645 IPv6
->LocalPort
= 0;
1646 IPv6
->RemotePort
= 0;
1648 return (EFI_DEVICE_PATH_PROTOCOL
*) IPv6
;
1652 EFI_DEVICE_PATH_PROTOCOL
*
1653 DevPathFromTextUart (
1654 IN CHAR16
*TextDeviceNode
1658 CHAR16
*DataBitsStr
;
1660 CHAR16
*StopBitsStr
;
1661 UART_DEVICE_PATH
*Uart
;
1663 BaudStr
= GetNextParamStr (&TextDeviceNode
);
1664 DataBitsStr
= GetNextParamStr (&TextDeviceNode
);
1665 ParityStr
= GetNextParamStr (&TextDeviceNode
);
1666 StopBitsStr
= GetNextParamStr (&TextDeviceNode
);
1667 Uart
= (UART_DEVICE_PATH
*) CreateDeviceNode (
1668 MESSAGING_DEVICE_PATH
,
1670 sizeof (UART_DEVICE_PATH
)
1673 Uart
->BaudRate
= (StrCmp (BaudStr
, L
"DEFAULT") == 0) ? 115200 : Dtoi (BaudStr
);
1674 Uart
->DataBits
= (UINT8
) ((StrCmp (DataBitsStr
, L
"DEFAULT") == 0) ? 8 : Dtoi (DataBitsStr
));
1675 switch (*ParityStr
) {
1700 Uart
->Parity
= 0xff;
1703 if (StrCmp (StopBitsStr
, L
"D") == 0) {
1704 Uart
->StopBits
= (UINT8
) 0;
1705 } else if (StrCmp (StopBitsStr
, L
"1") == 0) {
1706 Uart
->StopBits
= (UINT8
) 1;
1707 } else if (StrCmp (StopBitsStr
, L
"1.5") == 0) {
1708 Uart
->StopBits
= (UINT8
) 2;
1709 } else if (StrCmp (StopBitsStr
, L
"2") == 0) {
1710 Uart
->StopBits
= (UINT8
) 3;
1712 Uart
->StopBits
= 0xff;
1715 return (EFI_DEVICE_PATH_PROTOCOL
*) Uart
;
1719 EFI_DEVICE_PATH_PROTOCOL
*
1720 ConvertFromTextUsbClass (
1721 IN CHAR16
*TextDeviceNode
,
1722 IN USB_CLASS_TEXT
*UsbClassText
1728 CHAR16
*SubClassStr
;
1729 CHAR16
*ProtocolStr
;
1730 USB_CLASS_DEVICE_PATH
*UsbClass
;
1732 UsbClass
= (USB_CLASS_DEVICE_PATH
*) CreateDeviceNode (
1733 MESSAGING_DEVICE_PATH
,
1735 sizeof (USB_CLASS_DEVICE_PATH
)
1738 VIDStr
= GetNextParamStr (&TextDeviceNode
);
1739 PIDStr
= GetNextParamStr (&TextDeviceNode
);
1740 if (UsbClassText
->ClassExist
) {
1741 ClassStr
= GetNextParamStr (&TextDeviceNode
);
1742 UsbClass
->DeviceClass
= (UINT8
) Strtoi (ClassStr
);
1744 UsbClass
->DeviceClass
= UsbClassText
->Class
;
1746 if (UsbClassText
->SubClassExist
) {
1747 SubClassStr
= GetNextParamStr (&TextDeviceNode
);
1748 UsbClass
->DeviceSubClass
= (UINT8
) Strtoi (SubClassStr
);
1750 UsbClass
->DeviceSubClass
= UsbClassText
->SubClass
;
1753 ProtocolStr
= GetNextParamStr (&TextDeviceNode
);
1755 UsbClass
->VendorId
= (UINT16
) Strtoi (VIDStr
);
1756 UsbClass
->ProductId
= (UINT16
) Strtoi (PIDStr
);
1757 UsbClass
->DeviceProtocol
= (UINT8
) Strtoi (ProtocolStr
);
1759 return (EFI_DEVICE_PATH_PROTOCOL
*) UsbClass
;
1764 EFI_DEVICE_PATH_PROTOCOL
*
1765 DevPathFromTextUsbClass (
1766 IN CHAR16
*TextDeviceNode
1769 USB_CLASS_TEXT UsbClassText
;
1771 UsbClassText
.ClassExist
= TRUE
;
1772 UsbClassText
.SubClassExist
= TRUE
;
1774 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1778 EFI_DEVICE_PATH_PROTOCOL
*
1779 DevPathFromTextUsbAudio (
1780 IN CHAR16
*TextDeviceNode
1783 USB_CLASS_TEXT UsbClassText
;
1785 UsbClassText
.ClassExist
= FALSE
;
1786 UsbClassText
.Class
= USB_CLASS_AUDIO
;
1787 UsbClassText
.SubClassExist
= TRUE
;
1789 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1793 EFI_DEVICE_PATH_PROTOCOL
*
1794 DevPathFromTextUsbCDCControl (
1795 IN CHAR16
*TextDeviceNode
1798 USB_CLASS_TEXT UsbClassText
;
1800 UsbClassText
.ClassExist
= FALSE
;
1801 UsbClassText
.Class
= USB_CLASS_CDCCONTROL
;
1802 UsbClassText
.SubClassExist
= TRUE
;
1804 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1808 EFI_DEVICE_PATH_PROTOCOL
*
1809 DevPathFromTextUsbHID (
1810 IN CHAR16
*TextDeviceNode
1813 USB_CLASS_TEXT UsbClassText
;
1815 UsbClassText
.ClassExist
= FALSE
;
1816 UsbClassText
.Class
= USB_CLASS_HID
;
1817 UsbClassText
.SubClassExist
= TRUE
;
1819 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1823 EFI_DEVICE_PATH_PROTOCOL
*
1824 DevPathFromTextUsbImage (
1825 IN CHAR16
*TextDeviceNode
1828 USB_CLASS_TEXT UsbClassText
;
1830 UsbClassText
.ClassExist
= FALSE
;
1831 UsbClassText
.Class
= USB_CLASS_IMAGE
;
1832 UsbClassText
.SubClassExist
= TRUE
;
1834 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1838 EFI_DEVICE_PATH_PROTOCOL
*
1839 DevPathFromTextUsbPrinter (
1840 IN CHAR16
*TextDeviceNode
1843 USB_CLASS_TEXT UsbClassText
;
1845 UsbClassText
.ClassExist
= FALSE
;
1846 UsbClassText
.Class
= USB_CLASS_PRINTER
;
1847 UsbClassText
.SubClassExist
= TRUE
;
1849 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1853 EFI_DEVICE_PATH_PROTOCOL
*
1854 DevPathFromTextUsbMassStorage (
1855 IN CHAR16
*TextDeviceNode
1858 USB_CLASS_TEXT UsbClassText
;
1860 UsbClassText
.ClassExist
= FALSE
;
1861 UsbClassText
.Class
= USB_CLASS_MASS_STORAGE
;
1862 UsbClassText
.SubClassExist
= TRUE
;
1864 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1868 EFI_DEVICE_PATH_PROTOCOL
*
1869 DevPathFromTextUsbHub (
1870 IN CHAR16
*TextDeviceNode
1873 USB_CLASS_TEXT UsbClassText
;
1875 UsbClassText
.ClassExist
= FALSE
;
1876 UsbClassText
.Class
= USB_CLASS_HUB
;
1877 UsbClassText
.SubClassExist
= TRUE
;
1879 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1883 EFI_DEVICE_PATH_PROTOCOL
*
1884 DevPathFromTextUsbCDCData (
1885 IN CHAR16
*TextDeviceNode
1888 USB_CLASS_TEXT UsbClassText
;
1890 UsbClassText
.ClassExist
= FALSE
;
1891 UsbClassText
.Class
= USB_CLASS_CDCDATA
;
1892 UsbClassText
.SubClassExist
= TRUE
;
1894 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1898 EFI_DEVICE_PATH_PROTOCOL
*
1899 DevPathFromTextUsbSmartCard (
1900 IN CHAR16
*TextDeviceNode
1903 USB_CLASS_TEXT UsbClassText
;
1905 UsbClassText
.ClassExist
= FALSE
;
1906 UsbClassText
.Class
= USB_CLASS_SMART_CARD
;
1907 UsbClassText
.SubClassExist
= TRUE
;
1909 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1913 EFI_DEVICE_PATH_PROTOCOL
*
1914 DevPathFromTextUsbVideo (
1915 IN CHAR16
*TextDeviceNode
1918 USB_CLASS_TEXT UsbClassText
;
1920 UsbClassText
.ClassExist
= FALSE
;
1921 UsbClassText
.Class
= USB_CLASS_VIDEO
;
1922 UsbClassText
.SubClassExist
= TRUE
;
1924 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1928 EFI_DEVICE_PATH_PROTOCOL
*
1929 DevPathFromTextUsbDiagnostic (
1930 IN CHAR16
*TextDeviceNode
1933 USB_CLASS_TEXT UsbClassText
;
1935 UsbClassText
.ClassExist
= FALSE
;
1936 UsbClassText
.Class
= USB_CLASS_DIAGNOSTIC
;
1937 UsbClassText
.SubClassExist
= TRUE
;
1939 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1943 EFI_DEVICE_PATH_PROTOCOL
*
1944 DevPathFromTextUsbWireless (
1945 IN CHAR16
*TextDeviceNode
1948 USB_CLASS_TEXT UsbClassText
;
1950 UsbClassText
.ClassExist
= FALSE
;
1951 UsbClassText
.Class
= USB_CLASS_WIRELESS
;
1952 UsbClassText
.SubClassExist
= TRUE
;
1954 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1958 EFI_DEVICE_PATH_PROTOCOL
*
1959 DevPathFromTextUsbDeviceFirmwareUpdate (
1960 IN CHAR16
*TextDeviceNode
1963 USB_CLASS_TEXT UsbClassText
;
1965 UsbClassText
.ClassExist
= FALSE
;
1966 UsbClassText
.Class
= USB_CLASS_RESERVE
;
1967 UsbClassText
.SubClassExist
= FALSE
;
1968 UsbClassText
.SubClass
= USB_SUBCLASS_FW_UPDATE
;
1970 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1974 EFI_DEVICE_PATH_PROTOCOL
*
1975 DevPathFromTextUsbIrdaBridge (
1976 IN CHAR16
*TextDeviceNode
1979 USB_CLASS_TEXT UsbClassText
;
1981 UsbClassText
.ClassExist
= FALSE
;
1982 UsbClassText
.Class
= USB_CLASS_RESERVE
;
1983 UsbClassText
.SubClassExist
= FALSE
;
1984 UsbClassText
.SubClass
= USB_SUBCLASS_IRDA_BRIDGE
;
1986 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1990 EFI_DEVICE_PATH_PROTOCOL
*
1991 DevPathFromTextUsbTestAndMeasurement (
1992 IN CHAR16
*TextDeviceNode
1995 USB_CLASS_TEXT UsbClassText
;
1997 UsbClassText
.ClassExist
= FALSE
;
1998 UsbClassText
.Class
= USB_CLASS_RESERVE
;
1999 UsbClassText
.SubClassExist
= FALSE
;
2000 UsbClassText
.SubClass
= USB_SUBCLASS_TEST
;
2002 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
2006 EFI_DEVICE_PATH_PROTOCOL
*
2007 DevPathFromTextUsbWwid (
2008 IN CHAR16
*TextDeviceNode
2013 CHAR16
*InterfaceNumStr
;
2014 CHAR16
*SerialNumberStr
;
2015 USB_WWID_DEVICE_PATH
*UsbWwid
;
2017 VIDStr
= GetNextParamStr (&TextDeviceNode
);
2018 PIDStr
= GetNextParamStr (&TextDeviceNode
);
2019 InterfaceNumStr
= GetNextParamStr (&TextDeviceNode
);
2020 SerialNumberStr
= GetNextParamStr (&TextDeviceNode
);
2021 UsbWwid
= (USB_WWID_DEVICE_PATH
*) CreateDeviceNode (
2022 MESSAGING_DEVICE_PATH
,
2024 (UINT16
) (sizeof (USB_WWID_DEVICE_PATH
) + StrSize (SerialNumberStr
))
2027 UsbWwid
->VendorId
= (UINT16
) Strtoi (VIDStr
);
2028 UsbWwid
->ProductId
= (UINT16
) Strtoi (PIDStr
);
2029 UsbWwid
->InterfaceNumber
= (UINT16
) Strtoi (InterfaceNumStr
);
2030 StrCpy ((CHAR16
*) ((UINT8
*) UsbWwid
+ sizeof (USB_WWID_DEVICE_PATH
)), SerialNumberStr
);
2032 return (EFI_DEVICE_PATH_PROTOCOL
*) UsbWwid
;
2036 EFI_DEVICE_PATH_PROTOCOL
*
2037 DevPathFromTextUnit (
2038 IN CHAR16
*TextDeviceNode
2042 DEVICE_LOGICAL_UNIT_DEVICE_PATH
*LogicalUnit
;
2044 LunStr
= GetNextParamStr (&TextDeviceNode
);
2045 LogicalUnit
= (DEVICE_LOGICAL_UNIT_DEVICE_PATH
*) CreateDeviceNode (
2046 MESSAGING_DEVICE_PATH
,
2047 MSG_DEVICE_LOGICAL_UNIT_DP
,
2048 (UINT16
) sizeof (DEVICE_LOGICAL_UNIT_DEVICE_PATH
)
2051 LogicalUnit
->Lun
= (UINT8
) Strtoi (LunStr
);
2053 return (EFI_DEVICE_PATH_PROTOCOL
*) LogicalUnit
;
2057 EFI_DEVICE_PATH_PROTOCOL
*
2058 DevPathFromTextiSCSI (
2059 IN CHAR16
*TextDeviceNode
2064 CHAR16
*PortalGroupStr
;
2066 CHAR16
*HeaderDigestStr
;
2067 CHAR16
*DataDigestStr
;
2068 CHAR16
*AuthenticationStr
;
2069 CHAR16
*ProtocolStr
;
2071 ISCSI_DEVICE_PATH_WITH_NAME
*iSCSI
;
2073 NameStr
= GetNextParamStr (&TextDeviceNode
);
2074 PortalGroupStr
= GetNextParamStr (&TextDeviceNode
);
2075 LunStr
= GetNextParamStr (&TextDeviceNode
);
2076 HeaderDigestStr
= GetNextParamStr (&TextDeviceNode
);
2077 DataDigestStr
= GetNextParamStr (&TextDeviceNode
);
2078 AuthenticationStr
= GetNextParamStr (&TextDeviceNode
);
2079 ProtocolStr
= GetNextParamStr (&TextDeviceNode
);
2080 iSCSI
= (ISCSI_DEVICE_PATH_WITH_NAME
*) CreateDeviceNode (
2081 MESSAGING_DEVICE_PATH
,
2083 (UINT16
) (sizeof (ISCSI_DEVICE_PATH_WITH_NAME
) + StrLen (NameStr
) * 2)
2086 AsciiStr
= iSCSI
->iSCSITargetName
;
2087 StrToAscii (NameStr
, &AsciiStr
);
2089 iSCSI
->TargetPortalGroupTag
= (UINT16
) Strtoi (PortalGroupStr
);
2090 Strtoi64 (LunStr
, &iSCSI
->Lun
);
2093 if (StrCmp (HeaderDigestStr
, L
"CRC32C") == 0) {
2097 if (StrCmp (DataDigestStr
, L
"CRC32C") == 0) {
2101 if (StrCmp (AuthenticationStr
, L
"None") == 0) {
2105 if (StrCmp (AuthenticationStr
, L
"CHAP_UNI") == 0) {
2109 iSCSI
->LoginOption
= (UINT16
) Options
;
2111 iSCSI
->NetworkProtocol
= (UINT16
) StrCmp (ProtocolStr
, L
"TCP");
2113 return (EFI_DEVICE_PATH_PROTOCOL
*) iSCSI
;
2117 EFI_DEVICE_PATH_PROTOCOL
*
2119 IN CHAR16
*TextDeviceNode
2122 CHAR16
*PartitionStr
;
2124 CHAR16
*SignatureStr
;
2128 EFI_GUID SignatureGuid
;
2129 HARDDRIVE_DEVICE_PATH
*Hd
;
2131 PartitionStr
= GetNextParamStr (&TextDeviceNode
);
2132 TypeStr
= GetNextParamStr (&TextDeviceNode
);
2133 SignatureStr
= GetNextParamStr (&TextDeviceNode
);
2134 StartStr
= GetNextParamStr (&TextDeviceNode
);
2135 SizeStr
= GetNextParamStr (&TextDeviceNode
);
2136 Hd
= (HARDDRIVE_DEVICE_PATH
*) CreateDeviceNode (
2139 sizeof (HARDDRIVE_DEVICE_PATH
)
2142 Hd
->PartitionNumber
= (UINT32
) Dtoi (PartitionStr
);
2144 ZeroMem (Hd
->Signature
, 16);
2145 Hd
->MBRType
= (UINT8
) 0;
2147 if (StrCmp (TypeStr
, L
"MBR") == 0) {
2148 Hd
->SignatureType
= SIGNATURE_TYPE_MBR
;
2151 Signature32
= (UINT32
) Strtoi (SignatureStr
);
2152 CopyMem (Hd
->Signature
, &Signature32
, sizeof (UINT32
));
2153 } else if (StrCmp (TypeStr
, L
"GPT") == 0) {
2154 Hd
->SignatureType
= SIGNATURE_TYPE_GUID
;
2157 StrToGuid (SignatureStr
, &SignatureGuid
);
2158 CopyMem (Hd
->Signature
, &SignatureGuid
, sizeof (EFI_GUID
));
2160 Hd
->SignatureType
= (UINT8
) Strtoi (TypeStr
);
2163 Strtoi64 (StartStr
, &Hd
->PartitionStart
);
2164 Strtoi64 (SizeStr
, &Hd
->PartitionSize
);
2166 return (EFI_DEVICE_PATH_PROTOCOL
*) Hd
;
2170 EFI_DEVICE_PATH_PROTOCOL
*
2171 DevPathFromTextCDROM (
2172 IN CHAR16
*TextDeviceNode
2178 CDROM_DEVICE_PATH
*CDROM
;
2180 EntryStr
= GetNextParamStr (&TextDeviceNode
);
2181 StartStr
= GetNextParamStr (&TextDeviceNode
);
2182 SizeStr
= GetNextParamStr (&TextDeviceNode
);
2183 CDROM
= (CDROM_DEVICE_PATH
*) CreateDeviceNode (
2186 sizeof (CDROM_DEVICE_PATH
)
2189 CDROM
->BootEntry
= (UINT32
) Strtoi (EntryStr
);
2190 Strtoi64 (StartStr
, &CDROM
->PartitionStart
);
2191 Strtoi64 (SizeStr
, &CDROM
->PartitionSize
);
2193 return (EFI_DEVICE_PATH_PROTOCOL
*) CDROM
;
2197 EFI_DEVICE_PATH_PROTOCOL
*
2198 DevPathFromTextVenMEDIA (
2199 IN CHAR16
*TextDeviceNode
2202 return ConvertFromTextVendor (
2210 EFI_DEVICE_PATH_PROTOCOL
*
2211 DevPathFromTextFilePath (
2212 IN CHAR16
*TextDeviceNode
2215 FILEPATH_DEVICE_PATH
*File
;
2217 File
= (FILEPATH_DEVICE_PATH
*) CreateDeviceNode (
2220 (UINT16
) (sizeof (FILEPATH_DEVICE_PATH
) + StrLen (TextDeviceNode
) * 2)
2223 StrCpy (File
->PathName
, TextDeviceNode
);
2225 return (EFI_DEVICE_PATH_PROTOCOL
*) File
;
2229 EFI_DEVICE_PATH_PROTOCOL
*
2230 DevPathFromTextMedia (
2231 IN CHAR16
*TextDeviceNode
2235 MEDIA_PROTOCOL_DEVICE_PATH
*Media
;
2237 GuidStr
= GetNextParamStr (&TextDeviceNode
);
2238 Media
= (MEDIA_PROTOCOL_DEVICE_PATH
*) CreateDeviceNode (
2241 sizeof (MEDIA_PROTOCOL_DEVICE_PATH
)
2244 StrToGuid (GuidStr
, &Media
->Protocol
);
2246 return (EFI_DEVICE_PATH_PROTOCOL
*) Media
;
2250 EFI_DEVICE_PATH_PROTOCOL
*
2252 IN CHAR16
*TextDeviceNode
2256 MEDIA_FW_VOL_DEVICE_PATH
*Fv
;
2258 GuidStr
= GetNextParamStr (&TextDeviceNode
);
2259 Fv
= (MEDIA_FW_VOL_DEVICE_PATH
*) CreateDeviceNode (
2261 MEDIA_PIWG_FW_VOL_DP
,
2262 sizeof (MEDIA_FW_VOL_DEVICE_PATH
)
2265 StrToGuid (GuidStr
, &Fv
->FvName
);
2267 return (EFI_DEVICE_PATH_PROTOCOL
*) Fv
;
2271 EFI_DEVICE_PATH_PROTOCOL
*
2272 DevPathFromTextFvFile (
2273 IN CHAR16
*TextDeviceNode
2277 MEDIA_FW_VOL_FILEPATH_DEVICE_PATH
*FvFile
;
2279 GuidStr
= GetNextParamStr (&TextDeviceNode
);
2280 FvFile
= (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH
*) CreateDeviceNode (
2282 MEDIA_PIWG_FW_FILE_DP
,
2283 sizeof (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH
)
2286 StrToGuid (GuidStr
, &FvFile
->FvFileName
);
2288 return (EFI_DEVICE_PATH_PROTOCOL
*) FvFile
;
2292 EFI_DEVICE_PATH_PROTOCOL
*
2293 DevPathFromTextBBS (
2294 IN CHAR16
*TextDeviceNode
2301 BBS_BBS_DEVICE_PATH
*Bbs
;
2303 TypeStr
= GetNextParamStr (&TextDeviceNode
);
2304 IdStr
= GetNextParamStr (&TextDeviceNode
);
2305 FlagsStr
= GetNextParamStr (&TextDeviceNode
);
2306 Bbs
= (BBS_BBS_DEVICE_PATH
*) CreateDeviceNode (
2309 (UINT16
) (sizeof (BBS_BBS_DEVICE_PATH
) + StrLen (IdStr
))
2312 if (StrCmp (TypeStr
, L
"Floppy") == 0) {
2313 Bbs
->DeviceType
= BBS_TYPE_FLOPPY
;
2314 } else if (StrCmp (TypeStr
, L
"HD") == 0) {
2315 Bbs
->DeviceType
= BBS_TYPE_HARDDRIVE
;
2316 } else if (StrCmp (TypeStr
, L
"CDROM") == 0) {
2317 Bbs
->DeviceType
= BBS_TYPE_CDROM
;
2318 } else if (StrCmp (TypeStr
, L
"PCMCIA") == 0) {
2319 Bbs
->DeviceType
= BBS_TYPE_PCMCIA
;
2320 } else if (StrCmp (TypeStr
, L
"USB") == 0) {
2321 Bbs
->DeviceType
= BBS_TYPE_USB
;
2322 } else if (StrCmp (TypeStr
, L
"Network") == 0) {
2323 Bbs
->DeviceType
= BBS_TYPE_EMBEDDED_NETWORK
;
2325 Bbs
->DeviceType
= (UINT16
) Strtoi (TypeStr
);
2328 AsciiStr
= Bbs
->String
;
2329 StrToAscii (IdStr
, &AsciiStr
);
2331 Bbs
->StatusFlag
= (UINT16
) Strtoi (FlagsStr
);
2333 return (EFI_DEVICE_PATH_PROTOCOL
*) Bbs
;
2337 EFI_DEVICE_PATH_PROTOCOL
*
2338 DevPathFromTextSata (
2339 IN CHAR16
*TextDeviceNode
2342 SATA_DEVICE_PATH
*Sata
;
2348 // The PMPN is optional.
2350 Param1
= GetNextParamStr (&TextDeviceNode
);
2351 Param2
= GetNextParamStr (&TextDeviceNode
);
2353 if (!IS_NULL (TextDeviceNode
)) {
2354 Param3
= GetNextParamStr (&TextDeviceNode
);
2357 Sata
= (SATA_DEVICE_PATH
*) CreateDeviceNode (
2358 MESSAGING_DEVICE_PATH
,
2360 sizeof (SATA_DEVICE_PATH
)
2362 Sata
->HBAPortNumber
= (UINT16
) Xtoi (Param1
);
2363 if (Param3
!= NULL
) {
2364 Sata
->PortMultiplierPortNumber
= (UINT16
) Xtoi (Param2
);
2367 Sata
->PortMultiplierPortNumber
= 0;
2369 Sata
->Lun
= (UINT16
) Xtoi (Param2
);
2371 return (EFI_DEVICE_PATH_PROTOCOL
*) Sata
;
2374 GLOBAL_REMOVE_IF_UNREFERENCED DEVICE_PATH_FROM_TEXT_TABLE DevPathFromTextTable
[] = {
2375 {L
"Pci", DevPathFromTextPci
},
2376 {L
"PcCard", DevPathFromTextPcCard
},
2377 {L
"MemoryMapped", DevPathFromTextMemoryMapped
},
2378 {L
"VenHw", DevPathFromTextVenHw
},
2379 {L
"Ctrl", DevPathFromTextCtrl
},
2380 {L
"Acpi", DevPathFromTextAcpi
},
2381 {L
"PciRoot", DevPathFromTextPciRoot
},
2382 {L
"Floppy", DevPathFromTextFloppy
},
2383 {L
"Keyboard", DevPathFromTextKeyboard
},
2384 {L
"Serial", DevPathFromTextSerial
},
2385 {L
"ParallelPort", DevPathFromTextParallelPort
},
2386 {L
"AcpiEx", DevPathFromTextAcpiEx
},
2387 {L
"AcpiExp", DevPathFromTextAcpiExp
},
2388 {L
"Ata", DevPathFromTextAta
},
2389 {L
"Scsi", DevPathFromTextScsi
},
2390 {L
"Fibre", DevPathFromTextFibre
},
2391 {L
"I1394", DevPathFromText1394
},
2392 {L
"USB", DevPathFromTextUsb
},
2393 {L
"I2O", DevPathFromTextI2O
},
2394 {L
"Infiniband", DevPathFromTextInfiniband
},
2395 {L
"VenMsg", DevPathFromTextVenMsg
},
2396 {L
"VenPcAnsi", DevPathFromTextVenPcAnsi
},
2397 {L
"VenVt100", DevPathFromTextVenVt100
},
2398 {L
"VenVt100Plus", DevPathFromTextVenVt100Plus
},
2399 {L
"VenUtf8", DevPathFromTextVenUtf8
},
2400 {L
"UartFlowCtrl", DevPathFromTextUartFlowCtrl
},
2401 {L
"SAS", DevPathFromTextSAS
},
2402 {L
"DebugPort", DevPathFromTextDebugPort
},
2403 {L
"MAC", DevPathFromTextMAC
},
2404 {L
"IPv4", DevPathFromTextIPv4
},
2405 {L
"IPv6", DevPathFromTextIPv6
},
2406 {L
"Uart", DevPathFromTextUart
},
2407 {L
"UsbClass", DevPathFromTextUsbClass
},
2408 {L
"UsbAudio", DevPathFromTextUsbAudio
},
2409 {L
"UsbCDCControl", DevPathFromTextUsbCDCControl
},
2410 {L
"UsbHID", DevPathFromTextUsbHID
},
2411 {L
"UsbImage", DevPathFromTextUsbImage
},
2412 {L
"UsbPrinter", DevPathFromTextUsbPrinter
},
2413 {L
"UsbMassStorage", DevPathFromTextUsbMassStorage
},
2414 {L
"UsbHub", DevPathFromTextUsbHub
},
2415 {L
"UsbCDCData", DevPathFromTextUsbCDCData
},
2416 {L
"UsbSmartCard", DevPathFromTextUsbSmartCard
},
2417 {L
"UsbVideo", DevPathFromTextUsbVideo
},
2418 {L
"UsbDiagnostic", DevPathFromTextUsbDiagnostic
},
2419 {L
"UsbWireless", DevPathFromTextUsbWireless
},
2420 {L
"UsbDeviceFirmwareUpdate", DevPathFromTextUsbDeviceFirmwareUpdate
},
2421 {L
"UsbIrdaBridge", DevPathFromTextUsbIrdaBridge
},
2422 {L
"UsbTestAndMeasurement", DevPathFromTextUsbTestAndMeasurement
},
2423 {L
"UsbWwid", DevPathFromTextUsbWwid
},
2424 {L
"Unit", DevPathFromTextUnit
},
2425 {L
"iSCSI", DevPathFromTextiSCSI
},
2426 {L
"HD", DevPathFromTextHD
},
2427 {L
"CDROM", DevPathFromTextCDROM
},
2428 {L
"VenMEDIA", DevPathFromTextVenMEDIA
},
2429 {L
"Media", DevPathFromTextMedia
},
2430 {L
"Fv", DevPathFromTextFv
},
2431 {L
"FvFile", DevPathFromTextFvFile
},
2432 {L
"BBS", DevPathFromTextBBS
},
2433 {L
"Sata", DevPathFromTextSata
},
2437 EFI_DEVICE_PATH_PROTOCOL
*
2438 ConvertTextToDeviceNode (
2439 IN CONST CHAR16
*TextDeviceNode
2443 Routine Description:
2444 Convert text to the binary representation of a device node.
2447 TextDeviceNode - TextDeviceNode points to the text representation of a device
2448 node. Conversion starts with the first character and continues
2449 until the first non-device node character.
2452 A pointer - Pointer to the EFI device node.
2453 NULL - If TextDeviceNode is NULL or there was insufficient memory or text unsupported.
2457 EFI_DEVICE_PATH_PROTOCOL
* (*DumpNode
) (CHAR16
*);
2459 EFI_DEVICE_PATH_PROTOCOL
*DeviceNode
;
2460 CHAR16
*DeviceNodeStr
;
2463 if ((TextDeviceNode
== NULL
) || (IS_NULL (*TextDeviceNode
))) {
2469 DeviceNodeStr
= StrDuplicate (TextDeviceNode
);
2471 for (Index
= 0; DevPathFromTextTable
[Index
].Function
; Index
++) {
2472 ParamStr
= GetParamByNodeName (DeviceNodeStr
, DevPathFromTextTable
[Index
].DevicePathNodeText
);
2473 if (ParamStr
!= NULL
) {
2474 DumpNode
= DevPathFromTextTable
[Index
].Function
;
2479 if (DumpNode
== NULL
) {
2483 DumpNode
= DevPathFromTextFilePath
;
2484 DeviceNode
= DumpNode (DeviceNodeStr
);
2486 DeviceNode
= DumpNode (ParamStr
);
2487 FreePool (ParamStr
);
2490 FreePool (DeviceNodeStr
);
2495 EFI_DEVICE_PATH_PROTOCOL
*
2496 ConvertTextToDevicePath (
2497 IN CONST CHAR16
*TextDevicePath
2501 Routine Description:
2502 Convert text to the binary representation of a device path.
2505 TextDevicePath - TextDevicePath points to the text representation of a device
2506 path. Conversion starts with the first character and continues
2507 until the first non-device node character.
2510 A pointer - Pointer to the allocated device path.
2511 NULL - If TextDeviceNode is NULL or there was insufficient memory.
2515 EFI_DEVICE_PATH_PROTOCOL
* (*DumpNode
) (CHAR16
*);
2517 EFI_DEVICE_PATH_PROTOCOL
*DeviceNode
;
2519 EFI_DEVICE_PATH_PROTOCOL
*NewDevicePath
;
2520 CHAR16
*DevicePathStr
;
2522 CHAR16
*DeviceNodeStr
;
2523 UINT8 IsInstanceEnd
;
2524 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
2526 if ((TextDevicePath
== NULL
) || (IS_NULL (*TextDevicePath
))) {
2530 DevicePath
= (EFI_DEVICE_PATH_PROTOCOL
*) AllocatePool (END_DEVICE_PATH_LENGTH
);
2531 SetDevicePathEndNode (DevicePath
);
2534 DeviceNodeStr
= NULL
;
2535 DevicePathStr
= StrDuplicate (TextDevicePath
);
2537 Str
= DevicePathStr
;
2538 while ((DeviceNodeStr
= GetNextDeviceNodeStr (&Str
, &IsInstanceEnd
)) != NULL
) {
2540 for (Index
= 0; DevPathFromTextTable
[Index
].Function
; Index
++) {
2541 ParamStr
= GetParamByNodeName (DeviceNodeStr
, DevPathFromTextTable
[Index
].DevicePathNodeText
);
2542 if (ParamStr
!= NULL
) {
2543 DumpNode
= DevPathFromTextTable
[Index
].Function
;
2548 if (DumpNode
== NULL
) {
2552 DumpNode
= DevPathFromTextFilePath
;
2553 DeviceNode
= DumpNode (DeviceNodeStr
);
2555 DeviceNode
= DumpNode (ParamStr
);
2556 FreePool (ParamStr
);
2559 NewDevicePath
= AppendDeviceNodeProtocolInterface (DevicePath
, DeviceNode
);
2560 FreePool (DevicePath
);
2561 FreePool (DeviceNode
);
2562 DevicePath
= NewDevicePath
;
2564 if (IsInstanceEnd
) {
2565 DeviceNode
= (EFI_DEVICE_PATH_PROTOCOL
*) AllocatePool (END_DEVICE_PATH_LENGTH
);
2566 SetDevicePathInstanceEndNode (DeviceNode
);
2568 NewDevicePath
= AppendDeviceNodeProtocolInterface (DevicePath
, DeviceNode
);
2569 FreePool (DevicePath
);
2570 FreePool (DeviceNode
);
2571 DevicePath
= NewDevicePath
;
2575 FreePool (DevicePathStr
);