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"
44 Length
= StrLen ((CHAR16
*) Src
);
46 ReturnStr
= AllocateCopyPool ((Length
+ 1) * sizeof (CHAR16
), (VOID
*) Src
);
59 Get parameter in a pair of parentheses follow the given node name.
60 For example, given the "Pci(0,1)" and NodeName "Pci", it returns "0,1".
63 Str - Device Path Text
64 NodeName - Name of the node
67 Parameter text for the node
74 UINTN ParameterLength
;
77 // Check whether the node name matchs
79 NodeNameLength
= StrLen (NodeName
);
80 if (CompareMem (Str
, NodeName
, NodeNameLength
* sizeof (CHAR16
)) != 0) {
84 ParamStr
= Str
+ NodeNameLength
;
85 if (!IS_LEFT_PARENTH (*ParamStr
)) {
90 // Skip the found '(' and find first occurrence of ')'
94 StrPointer
= ParamStr
;
95 while (!IS_NULL (*StrPointer
)) {
96 if (IS_RIGHT_PARENTH (*StrPointer
)) {
102 if (IS_NULL (*StrPointer
)) {
109 ParamStr
= AllocateCopyPool ((ParameterLength
+ 1) * sizeof (CHAR16
), ParamStr
);
110 if (ParamStr
== NULL
) {
114 // Terminate the parameter string
116 ParamStr
[ParameterLength
] = L
'\0';
123 IN OUT CHAR16
**List
,
129 Get current sub-string from a string list, before return
130 the list header is moved to next sub-string. The sub-string is separated
131 by the specified character. For example, the separator is ',', the string
132 list is "2,0,3", it returns "2", the remain list move to "2,3"
135 List - A string list separated by the specified separator
136 Separator - The separator character
139 pointer - The current sub-string
149 if (IS_NULL (*Str
)) {
154 // Find first occurrence of the separator
156 while (!IS_NULL (*Str
)) {
157 if (*Str
== Separator
) {
163 if (*Str
== Separator
) {
165 // Find a sub-string, terminate it
172 // Move to next sub-string
185 // The separator is comma
187 return SplitStr (List
, L
',');
191 GetNextDeviceNodeStr (
192 IN OUT CHAR16
**DevicePath
,
193 OUT BOOLEAN
*IsInstanceEnd
198 Get one device node from entire device path text.
201 Str - The entire device path text string
202 IsInstanceEnd - This node is the end of a device path instance
205 a pointer - A device node text
206 NULL - No more device node available
212 UINTN ParenthesesStack
;
215 if (IS_NULL (*Str
)) {
220 // Skip the leading '/', '(', ')' and ','
222 while (!IS_NULL (*Str
)) {
223 if (!IS_SLASH (*Str
) &&
225 !IS_LEFT_PARENTH (*Str
) &&
226 !IS_RIGHT_PARENTH (*Str
)) {
235 // Scan for the separator of this device node, '/' or ','
237 ParenthesesStack
= 0;
238 while (!IS_NULL (*Str
)) {
239 if ((IS_COMMA (*Str
) || IS_SLASH (*Str
)) && (ParenthesesStack
== 0)) {
243 if (IS_LEFT_PARENTH (*Str
)) {
245 } else if (IS_RIGHT_PARENTH (*Str
)) {
252 if (ParenthesesStack
!= 0) {
254 // The '(' doesn't pair with ')', invalid device path text
259 if (IS_COMMA (*Str
)) {
260 *IsInstanceEnd
= TRUE
;
264 *IsInstanceEnd
= FALSE
;
265 if (!IS_NULL (*Str
)) {
284 Determines if a Unicode character is a hexadecimal digit.
285 The test is case insensitive.
288 Digit - Pointer to byte that receives the value of the hex character.
289 Char - Unicode character to test.
292 TRUE - If the character is a hexadecimal digit.
297 if ((Char
>= L
'0') && (Char
<= L
'9')) {
298 *Digit
= (UINT8
) (Char
- L
'0');
302 if ((Char
>= L
'A') && (Char
<= L
'F')) {
303 *Digit
= (UINT8
) (Char
- L
'A' + 0x0A);
307 if ((Char
>= L
'a') && (Char
<= L
'f')) {
308 *Digit
= (UINT8
) (Char
- L
'a' + 0x0A);
322 Converts the low nibble of a byte to hex unicode character.
325 Nibble - lower nibble of a byte.
328 Hex unicode character.
334 return (CHAR16
)(Nibble
+ L
'0');
337 return (CHAR16
)(Nibble
- 0xA + L
'A');
345 OUT UINTN
*ConvertedStrLen OPTIONAL
350 Converts Unicode string to binary buffer.
351 The conversion may be partial.
352 The first character in the string that is not hex digit stops the conversion.
353 At a minimum, any blob of data could be represented as a hex string.
356 Buf - Pointer to buffer that receives the data.
357 Len - Length in bytes of the buffer to hold converted data.
358 If routine return with EFI_SUCCESS, containing length of converted data.
359 If routine return with EFI_BUFFER_TOO_SMALL, containg length of buffer desired.
360 Str - String to be converted from.
361 ConvertedStrLen - Length of the Hex String consumed.
364 EFI_SUCCESS: Routine Success.
365 EFI_BUFFER_TOO_SMALL: The buffer is too small to hold converted data.
377 // Find out how many hex characters the string has.
379 for (Idx
= 0, HexCnt
= 0; IsHexDigit (&Digit
, Str
[Idx
]); Idx
++, HexCnt
++);
386 // Two Unicode characters make up 1 buffer byte. Round up.
388 BufferLength
= (HexCnt
+ 1) / 2;
391 // Test if buffer is passed enough.
393 if (BufferLength
> (*Len
)) {
395 return EFI_BUFFER_TOO_SMALL
;
400 for (Idx
= 0; Idx
< HexCnt
; Idx
++) {
402 IsHexDigit (&Digit
, Str
[HexCnt
- 1 - Idx
]);
405 // For odd charaters, write the lower nibble for each buffer byte,
406 // and for even characters, the upper nibble.
408 if ((Idx
& 1) == 0) {
419 if (ConvertedStrLen
!= NULL
) {
420 *ConvertedStrLen
= HexCnt
;
429 IN OUT UINTN
*HexStringBufferLength
,
436 Converts binary buffer to Unicode string.
437 At a minimum, any blob of data could be represented as a hex string.
440 Str - Pointer to the string.
441 HexStringBufferLength - Length in bytes of buffer to hold the hex string. Includes tailing '\0' character.
442 If routine return with EFI_SUCCESS, containing length of hex string buffer.
443 If routine return with EFI_BUFFER_TOO_SMALL, containg length of hex string buffer desired.
444 Buf - Buffer to be converted from.
445 Len - Length in bytes of the buffer to be converted.
448 EFI_SUCCESS: Routine success.
449 EFI_BUFFER_TOO_SMALL: The hex string buffer is too small.
458 // Make sure string is either passed or allocate enough.
459 // It takes 2 Unicode characters (4 bytes) to represent 1 byte of the binary buffer.
460 // Plus the Unicode termination character.
463 if (StrLen
> ((*HexStringBufferLength
) - 1)) {
464 *HexStringBufferLength
= StrLen
+ 1;
465 return EFI_BUFFER_TOO_SMALL
;
468 *HexStringBufferLength
= StrLen
+ 1;
474 for (Idx
= 0; Idx
< Len
; Idx
++) {
477 Str
[StrLen
- 1 - Idx
* 2] = NibbleToHexChar (Byte
);
478 Str
[StrLen
- 2 - Idx
* 2] = NibbleToHexChar ((UINT8
)(Byte
>> 4));
491 Skip the leading white space and '0x' or '0X' of a hex string
501 // skip preceeding white space
503 while (*Str
&& *Str
== ' ') {
507 // skip preceeding zeros
509 while (*Str
&& *Str
== '0') {
513 // skip preceeding white space
515 if (*Str
&& (*Str
== 'x' || *Str
== 'X')) {
530 Convert hex string to uint
543 ASSERT (Str
!= NULL
);
546 // convert hex digits
549 Length
= sizeof (UINTN
);
550 HexStringToBuf ((UINT8
*) &Rvalue
, &Length
, TrimHexStr (Str
), NULL
);
564 Convert hex string to 64 bit data.
577 Length
= sizeof (UINT64
);
578 HexStringToBuf ((UINT8
*) Data
, &Length
, TrimHexStr (Str
), NULL
);
589 Convert decimal string to uint
604 ASSERT (str
!= NULL
);
606 High
= (UINTN
) -1 / 10;
607 Low
= (UINTN
) -1 % 10;
609 // skip preceeding white space
611 while (*str
&& *str
== ' ') {
620 if (Char
>= '0' && Char
<= '9') {
621 if ((Rvalue
> High
|| Rvalue
== High
) && (Char
- '0' > (INTN
) Low
)) {
625 Rvalue
= (Rvalue
* 10) + Char
- '0';
639 IN UINTN BufferLength
,
649 // Two hex char make up one byte
651 StrLength
= BufferLength
* sizeof (CHAR16
);
653 for(Index
= 0; Index
< StrLength
; Index
++, Str
++) {
655 IsHexDigit (&Digit
, *Str
);
658 // For odd charaters, write the upper nibble for each buffer byte,
659 // and for even characters, the lower nibble.
661 if ((Index
& 1) == 0) {
664 Byte
= Buf
[Index
/ 2];
669 Buf
[Index
/ 2] = Byte
;
682 UINTN ConvertedStrLen
;
685 BufferLength
= sizeof (Guid
->Data1
);
686 Status
= HexStringToBuf ((UINT8
*) &Guid
->Data1
, &BufferLength
, Str
, &ConvertedStrLen
);
687 if (EFI_ERROR (Status
)) {
690 Str
+= ConvertedStrLen
;
691 if (IS_HYPHEN (*Str
)) {
694 return EFI_UNSUPPORTED
;
697 BufferLength
= sizeof (Guid
->Data2
);
698 Status
= HexStringToBuf ((UINT8
*) &Guid
->Data2
, &BufferLength
, Str
, &ConvertedStrLen
);
699 if (EFI_ERROR (Status
)) {
702 Str
+= ConvertedStrLen
;
703 if (IS_HYPHEN (*Str
)) {
706 return EFI_UNSUPPORTED
;
709 BufferLength
= sizeof (Guid
->Data3
);
710 Status
= HexStringToBuf ((UINT8
*) &Guid
->Data3
, &BufferLength
, Str
, &ConvertedStrLen
);
711 if (EFI_ERROR (Status
)) {
714 Str
+= ConvertedStrLen
;
715 if (IS_HYPHEN (*Str
)) {
718 return EFI_UNSUPPORTED
;
721 StrToBuf (&Guid
->Data4
[0], 2, Str
);
723 // Skip 2 byte hex chars
727 if (IS_HYPHEN (*Str
)) {
730 return EFI_UNSUPPORTED
;
732 StrToBuf (&Guid
->Data4
[2], 6, Str
);
740 OUT EFI_IPv4_ADDRESS
*IPv4Addr
745 for (Index
= 0; Index
< 4; Index
++) {
746 IPv4Addr
->Addr
[Index
] = (UINT8
) Atoi (SplitStr (Str
, L
'.'));
753 OUT EFI_IPv6_ADDRESS
*IPv6Addr
759 for (Index
= 0; Index
< 8; Index
++) {
760 Data
= (UINT16
) Xtoi (SplitStr (Str
, L
':'));
761 IPv6Addr
->Addr
[Index
* 2] = (UINT8
) (Data
>> 8);
762 IPv6Addr
->Addr
[Index
* 2 + 1] = (UINT8
) (Data
& 0xff);
769 IN OUT CHAR8
**AsciiStr
775 while (!IS_NULL (*Str
)) {
776 *(Dest
++) = (CHAR8
) *(Str
++);
781 // Return the string next to it
783 *AsciiStr
= Dest
+ 1;
786 EFI_DEVICE_PATH_PROTOCOL
*
788 IN CHAR16
*TextDeviceNode
793 PCI_DEVICE_PATH
*Pci
;
795 FunctionStr
= GetNextParamStr (&TextDeviceNode
);
796 DeviceStr
= GetNextParamStr (&TextDeviceNode
);
797 Pci
= (PCI_DEVICE_PATH
*) CreateDeviceNode (
798 HARDWARE_DEVICE_PATH
,
800 sizeof (PCI_DEVICE_PATH
)
803 Pci
->Function
= (UINT8
) Xtoi (FunctionStr
);
804 Pci
->Device
= (UINT8
) Xtoi (DeviceStr
);
806 return (EFI_DEVICE_PATH_PROTOCOL
*) Pci
;
809 EFI_DEVICE_PATH_PROTOCOL
*
810 DevPathFromTextPcCard (
811 IN CHAR16
*TextDeviceNode
814 CHAR16
*FunctionNumberStr
;
815 PCCARD_DEVICE_PATH
*Pccard
;
817 FunctionNumberStr
= GetNextParamStr (&TextDeviceNode
);
818 Pccard
= (PCCARD_DEVICE_PATH
*) CreateDeviceNode (
819 HARDWARE_DEVICE_PATH
,
821 sizeof (PCCARD_DEVICE_PATH
)
824 Pccard
->FunctionNumber
= (UINT8
) Xtoi (FunctionNumberStr
);
826 return (EFI_DEVICE_PATH_PROTOCOL
*) Pccard
;
829 EFI_DEVICE_PATH_PROTOCOL
*
830 DevPathFromTextMemoryMapped (
831 IN CHAR16
*TextDeviceNode
834 CHAR16
*StartingAddressStr
;
835 CHAR16
*EndingAddressStr
;
836 MEMMAP_DEVICE_PATH
*MemMap
;
838 StartingAddressStr
= GetNextParamStr (&TextDeviceNode
);
839 EndingAddressStr
= GetNextParamStr (&TextDeviceNode
);
840 MemMap
= (MEMMAP_DEVICE_PATH
*) CreateDeviceNode (
841 HARDWARE_DEVICE_PATH
,
843 sizeof (MEMMAP_DEVICE_PATH
)
846 MemMap
->MemoryType
= 0;
848 Xtoi64 (StartingAddressStr
, &MemMap
->StartingAddress
);
849 Xtoi64 (EndingAddressStr
, &MemMap
->EndingAddress
);
851 return (EFI_DEVICE_PATH_PROTOCOL
*) MemMap
;
854 EFI_DEVICE_PATH_PROTOCOL
*
855 ConvertFromTextVendor (
856 IN CHAR16
*TextDeviceNode
,
864 VENDOR_DEVICE_PATH
*Vendor
;
866 GuidStr
= GetNextParamStr (&TextDeviceNode
);
868 DataStr
= GetNextParamStr (&TextDeviceNode
);
869 Length
= StrLen (DataStr
);
871 // Two hex characters make up 1 buffer byte
873 Length
= (Length
+ 1) / 2;
875 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
878 sizeof (VENDOR_DEVICE_PATH
) + (UINT16
) Length
881 StrToGuid (GuidStr
, &Vendor
->Guid
);
882 StrToBuf (((UINT8
*) Vendor
) + sizeof (VENDOR_DEVICE_PATH
), Length
, DataStr
);
884 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
887 EFI_DEVICE_PATH_PROTOCOL
*
888 DevPathFromTextVenHw (
889 IN CHAR16
*TextDeviceNode
892 return ConvertFromTextVendor (
894 HARDWARE_DEVICE_PATH
,
899 EFI_DEVICE_PATH_PROTOCOL
*
900 DevPathFromTextCtrl (
901 IN CHAR16
*TextDeviceNode
904 CHAR16
*ControllerStr
;
905 CONTROLLER_DEVICE_PATH
*Controller
;
907 ControllerStr
= GetNextParamStr (&TextDeviceNode
);
908 Controller
= (CONTROLLER_DEVICE_PATH
*) CreateDeviceNode (
909 HARDWARE_DEVICE_PATH
,
911 sizeof (CONTROLLER_DEVICE_PATH
)
913 Controller
->ControllerNumber
= (UINT32
) Xtoi (ControllerStr
);
915 return (EFI_DEVICE_PATH_PROTOCOL
*) Controller
;
918 EFI_DEVICE_PATH_PROTOCOL
*
919 DevPathFromTextAcpi (
920 IN CHAR16
*TextDeviceNode
925 ACPI_HID_DEVICE_PATH
*Acpi
;
927 HIDStr
= GetNextParamStr (&TextDeviceNode
);
928 UIDStr
= GetNextParamStr (&TextDeviceNode
);
929 Acpi
= (ACPI_HID_DEVICE_PATH
*) CreateDeviceNode (
932 sizeof (ACPI_HID_DEVICE_PATH
)
935 if ((HIDStr
[0] == L
'P') && (HIDStr
[1] == L
'N') && (HIDStr
[2] == L
'P')) {
939 Acpi
->HID
= EISA_PNP_ID (Xtoi (HIDStr
));
940 Acpi
->UID
= (UINT32
) Xtoi (UIDStr
);
942 return (EFI_DEVICE_PATH_PROTOCOL
*) Acpi
;
945 EFI_DEVICE_PATH_PROTOCOL
*
946 ConvertFromTextAcpi (
947 IN CHAR16
*TextDeviceNode
,
952 ACPI_HID_DEVICE_PATH
*Acpi
;
954 UIDStr
= GetNextParamStr (&TextDeviceNode
);
955 Acpi
= (ACPI_HID_DEVICE_PATH
*) CreateDeviceNode (
958 sizeof (ACPI_HID_DEVICE_PATH
)
962 Acpi
->UID
= (UINT32
) Xtoi (UIDStr
);
964 return (EFI_DEVICE_PATH_PROTOCOL
*) Acpi
;
967 EFI_DEVICE_PATH_PROTOCOL
*
968 DevPathFromTextPciRoot (
969 IN CHAR16
*TextDeviceNode
972 return ConvertFromTextAcpi (TextDeviceNode
, 0x0a0341d0);
975 EFI_DEVICE_PATH_PROTOCOL
*
976 DevPathFromTextFloppy (
977 IN CHAR16
*TextDeviceNode
980 return ConvertFromTextAcpi (TextDeviceNode
, 0x060441d0);
983 EFI_DEVICE_PATH_PROTOCOL
*
984 DevPathFromTextKeyboard (
985 IN CHAR16
*TextDeviceNode
988 return ConvertFromTextAcpi (TextDeviceNode
, 0x030141d0);
991 EFI_DEVICE_PATH_PROTOCOL
*
992 DevPathFromTextSerial (
993 IN CHAR16
*TextDeviceNode
996 return ConvertFromTextAcpi (TextDeviceNode
, 0x050141d0);
999 EFI_DEVICE_PATH_PROTOCOL
*
1000 DevPathFromTextParallelPort (
1001 IN CHAR16
*TextDeviceNode
1004 return ConvertFromTextAcpi (TextDeviceNode
, 0x040141d0);
1007 EFI_DEVICE_PATH_PROTOCOL
*
1008 DevPathFromTextAcpiEx (
1009 IN CHAR16
*TextDeviceNode
1020 ACPI_EXTENDED_HID_DEVICE_PATH_WITH_STR
*AcpiExt
;
1022 HIDStr
= GetNextParamStr (&TextDeviceNode
);
1023 CIDStr
= GetNextParamStr (&TextDeviceNode
);
1024 UIDStr
= GetNextParamStr (&TextDeviceNode
);
1025 HIDSTRStr
= GetNextParamStr (&TextDeviceNode
);
1026 CIDSTRStr
= GetNextParamStr (&TextDeviceNode
);
1027 UIDSTRStr
= GetNextParamStr (&TextDeviceNode
);
1028 Length
= sizeof (ACPI_EXTENDED_HID_DEVICE_PATH
) +
1029 (UINT16
) StrLen (HIDSTRStr
) + 1 +
1030 (UINT16
) StrLen (UIDSTRStr
) + 1 +
1031 (UINT16
) StrLen (CIDSTRStr
) + 1;
1032 AcpiExt
= (ACPI_EXTENDED_HID_DEVICE_PATH_WITH_STR
*) CreateDeviceNode (
1038 if ((HIDStr
[0] == L
'P') && (HIDStr
[1] == L
'N') && (HIDStr
[2] == L
'P')) {
1040 AcpiExt
->HID
= EISA_PNP_ID (Xtoi (HIDStr
));
1042 AcpiExt
->HID
= (UINT32
) Xtoi (HIDStr
);
1045 AcpiExt
->UID
= (UINT32
) Xtoi (UIDStr
);
1046 AcpiExt
->CID
= (UINT32
) Xtoi (CIDStr
);
1048 AsciiStr
= AcpiExt
->HidUidCidStr
;
1049 StrToAscii (HIDSTRStr
, &AsciiStr
);
1050 StrToAscii (UIDSTRStr
, &AsciiStr
);
1051 StrToAscii (CIDSTRStr
, &AsciiStr
);
1053 return (EFI_DEVICE_PATH_PROTOCOL
*) AcpiExt
;
1056 EFI_DEVICE_PATH_PROTOCOL
*
1057 DevPathFromTextAcpiExp (
1058 IN CHAR16
*TextDeviceNode
1066 ACPI_EXTENDED_HID_DEVICE_PATH_WITH_STR
*AcpiExt
;
1068 HIDStr
= GetNextParamStr (&TextDeviceNode
);
1069 CIDStr
= GetNextParamStr (&TextDeviceNode
);
1070 UIDSTRStr
= GetNextParamStr (&TextDeviceNode
);
1071 Length
= sizeof (ACPI_EXTENDED_HID_DEVICE_PATH
) + (UINT16
) StrLen (UIDSTRStr
) + 3;
1072 AcpiExt
= (ACPI_EXTENDED_HID_DEVICE_PATH_WITH_STR
*) CreateDeviceNode (
1078 if ((HIDStr
[0] == L
'P') && (HIDStr
[1] == L
'N') && (HIDStr
[2] == L
'P')) {
1080 AcpiExt
->HID
= EISA_PNP_ID (Xtoi (HIDStr
));
1082 AcpiExt
->HID
= (UINT32
) Xtoi (HIDStr
);
1086 AcpiExt
->CID
= (UINT32
) Xtoi (CIDStr
);
1088 AsciiStr
= AcpiExt
->HidUidCidStr
;
1090 // HID string is NULL
1094 // Convert UID string
1097 StrToAscii (UIDSTRStr
, &AsciiStr
);
1099 // CID string is NULL
1103 return (EFI_DEVICE_PATH_PROTOCOL
*) AcpiExt
;
1106 EFI_DEVICE_PATH_PROTOCOL
*
1107 DevPathFromTextAta (
1108 IN CHAR16
*TextDeviceNode
1111 CHAR16
*PrimarySecondaryStr
;
1112 CHAR16
*SlaveMasterStr
;
1114 ATAPI_DEVICE_PATH
*Atapi
;
1116 Atapi
= (ATAPI_DEVICE_PATH
*) CreateDeviceNode (
1117 MESSAGING_DEVICE_PATH
,
1119 sizeof (ATAPI_DEVICE_PATH
)
1122 PrimarySecondaryStr
= GetNextParamStr (&TextDeviceNode
);
1123 SlaveMasterStr
= GetNextParamStr (&TextDeviceNode
);
1124 LunStr
= GetNextParamStr (&TextDeviceNode
);
1126 Atapi
->PrimarySecondary
= (StrCmp (PrimarySecondaryStr
, L
"Primary") == 0) ? (UINT8
) 0 : (UINT8
) 1;
1127 Atapi
->SlaveMaster
= (StrCmp (SlaveMasterStr
, L
"Master") == 0) ? (UINT8
) 0 : (UINT8
) 1;
1128 Atapi
->Lun
= (UINT16
) Xtoi (LunStr
);
1130 return (EFI_DEVICE_PATH_PROTOCOL
*) Atapi
;
1133 EFI_DEVICE_PATH_PROTOCOL
*
1134 DevPathFromTextScsi (
1135 IN CHAR16
*TextDeviceNode
1140 SCSI_DEVICE_PATH
*Scsi
;
1142 PunStr
= GetNextParamStr (&TextDeviceNode
);
1143 LunStr
= GetNextParamStr (&TextDeviceNode
);
1144 Scsi
= (SCSI_DEVICE_PATH
*) CreateDeviceNode (
1145 MESSAGING_DEVICE_PATH
,
1147 sizeof (SCSI_DEVICE_PATH
)
1150 Scsi
->Pun
= (UINT16
) Xtoi (PunStr
);
1151 Scsi
->Lun
= (UINT16
) Xtoi (LunStr
);
1153 return (EFI_DEVICE_PATH_PROTOCOL
*) Scsi
;
1156 EFI_DEVICE_PATH_PROTOCOL
*
1157 DevPathFromTextFibre (
1158 IN CHAR16
*TextDeviceNode
1163 FIBRECHANNEL_DEVICE_PATH
*Fibre
;
1165 WWNStr
= GetNextParamStr (&TextDeviceNode
);
1166 LunStr
= GetNextParamStr (&TextDeviceNode
);
1167 Fibre
= (FIBRECHANNEL_DEVICE_PATH
*) CreateDeviceNode (
1168 MESSAGING_DEVICE_PATH
,
1169 MSG_FIBRECHANNEL_DP
,
1170 sizeof (FIBRECHANNEL_DEVICE_PATH
)
1173 Fibre
->Reserved
= 0;
1174 Xtoi64 (WWNStr
, &Fibre
->WWN
);
1175 Xtoi64 (LunStr
, &Fibre
->Lun
);
1177 return (EFI_DEVICE_PATH_PROTOCOL
*) Fibre
;
1180 EFI_DEVICE_PATH_PROTOCOL
*
1181 DevPathFromText1394 (
1182 IN CHAR16
*TextDeviceNode
1186 F1394_DEVICE_PATH
*F1394
;
1188 GuidStr
= GetNextParamStr (&TextDeviceNode
);
1189 F1394
= (F1394_DEVICE_PATH
*) CreateDeviceNode (
1190 MESSAGING_DEVICE_PATH
,
1192 sizeof (F1394_DEVICE_PATH
)
1195 F1394
->Reserved
= 0;
1196 Xtoi64 (GuidStr
, &F1394
->Guid
);
1198 return (EFI_DEVICE_PATH_PROTOCOL
*) F1394
;
1201 EFI_DEVICE_PATH_PROTOCOL
*
1202 DevPathFromTextUsb (
1203 IN CHAR16
*TextDeviceNode
1207 CHAR16
*InterfaceStr
;
1208 USB_DEVICE_PATH
*Usb
;
1210 PortStr
= GetNextParamStr (&TextDeviceNode
);
1211 InterfaceStr
= GetNextParamStr (&TextDeviceNode
);
1212 Usb
= (USB_DEVICE_PATH
*) CreateDeviceNode (
1213 MESSAGING_DEVICE_PATH
,
1215 sizeof (USB_DEVICE_PATH
)
1218 Usb
->ParentPortNumber
= (UINT8
) Xtoi (PortStr
);
1219 Usb
->InterfaceNumber
= (UINT8
) Xtoi (InterfaceStr
);
1221 return (EFI_DEVICE_PATH_PROTOCOL
*) Usb
;
1224 EFI_DEVICE_PATH_PROTOCOL
*
1225 DevPathFromTextI2O (
1226 IN CHAR16
*TextDeviceNode
1230 I2O_DEVICE_PATH
*I2O
;
1232 TIDStr
= GetNextParamStr (&TextDeviceNode
);
1233 I2O
= (I2O_DEVICE_PATH
*) CreateDeviceNode (
1234 MESSAGING_DEVICE_PATH
,
1236 sizeof (I2O_DEVICE_PATH
)
1239 I2O
->Tid
= (UINT32
) Xtoi (TIDStr
);
1241 return (EFI_DEVICE_PATH_PROTOCOL
*) I2O
;
1244 EFI_DEVICE_PATH_PROTOCOL
*
1245 DevPathFromTextInfiniband (
1246 IN CHAR16
*TextDeviceNode
1255 INFINIBAND_DEVICE_PATH
*InfiniBand
;
1257 FlagsStr
= GetNextParamStr (&TextDeviceNode
);
1258 GuidStr
= GetNextParamStr (&TextDeviceNode
);
1259 SidStr
= GetNextParamStr (&TextDeviceNode
);
1260 TidStr
= GetNextParamStr (&TextDeviceNode
);
1261 DidStr
= GetNextParamStr (&TextDeviceNode
);
1262 InfiniBand
= (INFINIBAND_DEVICE_PATH
*) CreateDeviceNode (
1263 MESSAGING_DEVICE_PATH
,
1265 sizeof (INFINIBAND_DEVICE_PATH
)
1268 InfiniBand
->ResourceFlags
= (UINT32
) Xtoi (FlagsStr
);
1269 StrToGuid (GuidStr
, &PortGid
);
1270 CopyMem (InfiniBand
->PortGid
, &PortGid
, sizeof (EFI_GUID
));
1271 Xtoi64 (SidStr
, &InfiniBand
->ServiceId
);
1272 Xtoi64 (TidStr
, &InfiniBand
->TargetPortId
);
1273 Xtoi64 (DidStr
, &InfiniBand
->DeviceId
);
1275 return (EFI_DEVICE_PATH_PROTOCOL
*) InfiniBand
;
1278 EFI_DEVICE_PATH_PROTOCOL
*
1279 DevPathFromTextVenMsg (
1280 IN CHAR16
*TextDeviceNode
1283 return ConvertFromTextVendor (
1285 MESSAGING_DEVICE_PATH
,
1290 EFI_DEVICE_PATH_PROTOCOL
*
1291 DevPathFromTextVenPcAnsi (
1292 IN CHAR16
*TextDeviceNode
1295 VENDOR_DEVICE_PATH
*Vendor
;
1297 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
1298 MESSAGING_DEVICE_PATH
,
1300 sizeof (VENDOR_DEVICE_PATH
));
1301 CopyGuid (&Vendor
->Guid
, &gEfiPcAnsiGuid
);
1303 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
1306 EFI_DEVICE_PATH_PROTOCOL
*
1307 DevPathFromTextVenVt100 (
1308 IN CHAR16
*TextDeviceNode
1311 VENDOR_DEVICE_PATH
*Vendor
;
1313 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
1314 MESSAGING_DEVICE_PATH
,
1316 sizeof (VENDOR_DEVICE_PATH
));
1317 CopyGuid (&Vendor
->Guid
, &gEfiVT100Guid
);
1319 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
1322 EFI_DEVICE_PATH_PROTOCOL
*
1323 DevPathFromTextVenVt100Plus (
1324 IN CHAR16
*TextDeviceNode
1327 VENDOR_DEVICE_PATH
*Vendor
;
1329 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
1330 MESSAGING_DEVICE_PATH
,
1332 sizeof (VENDOR_DEVICE_PATH
));
1333 CopyGuid (&Vendor
->Guid
, &gEfiVT100PlusGuid
);
1335 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
1338 EFI_DEVICE_PATH_PROTOCOL
*
1339 DevPathFromTextVenUtf8 (
1340 IN CHAR16
*TextDeviceNode
1343 VENDOR_DEVICE_PATH
*Vendor
;
1345 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
1346 MESSAGING_DEVICE_PATH
,
1348 sizeof (VENDOR_DEVICE_PATH
));
1349 CopyGuid (&Vendor
->Guid
, &gEfiVTUTF8Guid
);
1351 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
1354 EFI_DEVICE_PATH_PROTOCOL
*
1355 DevPathFromTextUartFlowCtrl (
1356 IN CHAR16
*TextDeviceNode
1360 UART_FLOW_CONTROL_DEVICE_PATH
*UartFlowControl
;
1362 ValueStr
= GetNextParamStr (&TextDeviceNode
);
1363 UartFlowControl
= (UART_FLOW_CONTROL_DEVICE_PATH
*) CreateDeviceNode (
1364 MESSAGING_DEVICE_PATH
,
1366 sizeof (UART_FLOW_CONTROL_DEVICE_PATH
)
1369 CopyGuid (&UartFlowControl
->Guid
, &mEfiDevicePathMessagingUartFlowControlGuid
);
1370 if (StrCmp (ValueStr
, L
"XonXoff") == 0) {
1371 UartFlowControl
->FlowControlMap
= 2;
1372 } else if (StrCmp (ValueStr
, L
"Hardware") == 0) {
1373 UartFlowControl
->FlowControlMap
= 1;
1375 UartFlowControl
->FlowControlMap
= 0;
1378 return (EFI_DEVICE_PATH_PROTOCOL
*) UartFlowControl
;
1381 EFI_DEVICE_PATH_PROTOCOL
*
1382 DevPathFromTextSAS (
1383 IN CHAR16
*TextDeviceNode
1390 CHAR16
*LocationStr
;
1392 CHAR16
*DriveBayStr
;
1393 CHAR16
*ReservedStr
;
1395 SAS_DEVICE_PATH
*Sas
;
1397 AddressStr
= GetNextParamStr (&TextDeviceNode
);
1398 LunStr
= GetNextParamStr (&TextDeviceNode
);
1399 RTPStr
= GetNextParamStr (&TextDeviceNode
);
1400 SASSATAStr
= GetNextParamStr (&TextDeviceNode
);
1401 LocationStr
= GetNextParamStr (&TextDeviceNode
);
1402 ConnectStr
= GetNextParamStr (&TextDeviceNode
);
1403 DriveBayStr
= GetNextParamStr (&TextDeviceNode
);
1404 ReservedStr
= GetNextParamStr (&TextDeviceNode
);
1406 Sas
= (SAS_DEVICE_PATH
*) CreateDeviceNode (
1407 MESSAGING_DEVICE_PATH
,
1409 sizeof (SAS_DEVICE_PATH
)
1412 CopyGuid (&Sas
->Guid
, &mEfiDevicePathMessagingSASGuid
);
1413 Xtoi64 (AddressStr
, &Sas
->SasAddress
);
1414 Xtoi64 (LunStr
, &Sas
->Lun
);
1415 Sas
->RelativeTargetPort
= (UINT16
) Xtoi (RTPStr
);
1416 if (StrCmp (SASSATAStr
, L
"NoTopology") == 0)
1419 if (StrCmp (DriveBayStr
, L
"0") == 0) {
1423 Info
|= (Xtoi (DriveBayStr
) << 8);
1426 if (StrCmp (SASSATAStr
, L
"SATA") == 0) {
1430 if (StrCmp (LocationStr
, L
"External") == 0) {
1434 if (StrCmp (ConnectStr
, L
"Expanded") == 0) {
1439 Sas
->DeviceTopology
= Info
;
1440 Sas
->Reserved
= (UINT32
) Xtoi (ReservedStr
);
1442 return (EFI_DEVICE_PATH_PROTOCOL
*) Sas
;
1445 EFI_DEVICE_PATH_PROTOCOL
*
1446 DevPathFromTextDebugPort (
1447 IN CHAR16
*TextDeviceNode
1450 VENDOR_DEFINED_MESSAGING_DEVICE_PATH
*Vend
;
1452 Vend
= (VENDOR_DEFINED_MESSAGING_DEVICE_PATH
*) CreateDeviceNode (
1453 MESSAGING_DEVICE_PATH
,
1455 sizeof (VENDOR_DEFINED_MESSAGING_DEVICE_PATH
)
1458 CopyGuid (&Vend
->Guid
, &gEfiDebugPortProtocolGuid
);
1460 return (EFI_DEVICE_PATH_PROTOCOL
*) Vend
;
1463 EFI_DEVICE_PATH_PROTOCOL
*
1464 DevPathFromTextMAC (
1465 IN CHAR16
*TextDeviceNode
1471 MAC_ADDR_DEVICE_PATH
*MAC
;
1473 AddressStr
= GetNextParamStr (&TextDeviceNode
);
1474 IfTypeStr
= GetNextParamStr (&TextDeviceNode
);
1475 MAC
= (MAC_ADDR_DEVICE_PATH
*) CreateDeviceNode (
1476 MESSAGING_DEVICE_PATH
,
1478 sizeof (MAC_ADDR_DEVICE_PATH
)
1481 MAC
->IfType
= (UINT8
) Xtoi (IfTypeStr
);
1483 Length
= sizeof (EFI_MAC_ADDRESS
);
1484 StrToBuf (&MAC
->MacAddress
.Addr
[0], Length
, AddressStr
);
1486 return (EFI_DEVICE_PATH_PROTOCOL
*) MAC
;
1489 EFI_DEVICE_PATH_PROTOCOL
*
1490 DevPathFromTextIPv4 (
1491 IN CHAR16
*TextDeviceNode
1494 CHAR16
*RemoteIPStr
;
1495 CHAR16
*ProtocolStr
;
1498 IPv4_DEVICE_PATH
*IPv4
;
1500 RemoteIPStr
= GetNextParamStr (&TextDeviceNode
);
1501 ProtocolStr
= GetNextParamStr (&TextDeviceNode
);
1502 TypeStr
= GetNextParamStr (&TextDeviceNode
);
1503 LocalIPStr
= GetNextParamStr (&TextDeviceNode
);
1504 IPv4
= (IPv4_DEVICE_PATH
*) CreateDeviceNode (
1505 MESSAGING_DEVICE_PATH
,
1507 sizeof (IPv4_DEVICE_PATH
)
1510 StrToIPv4Addr (&RemoteIPStr
, &IPv4
->RemoteIpAddress
);
1511 IPv4
->Protocol
= (StrCmp (ProtocolStr
, L
"UDP") == 0) ? (UINT16
) 0 : (UINT16
) 1;
1512 if (StrCmp (TypeStr
, L
"Static") == 0) {
1513 IPv4
->StaticIpAddress
= TRUE
;
1515 IPv4
->StaticIpAddress
= FALSE
;
1518 StrToIPv4Addr (&LocalIPStr
, &IPv4
->LocalIpAddress
);
1520 IPv4
->LocalPort
= 0;
1521 IPv4
->RemotePort
= 0;
1523 return (EFI_DEVICE_PATH_PROTOCOL
*) IPv4
;
1526 EFI_DEVICE_PATH_PROTOCOL
*
1527 DevPathFromTextIPv6 (
1528 IN CHAR16
*TextDeviceNode
1531 CHAR16
*RemoteIPStr
;
1532 CHAR16
*ProtocolStr
;
1535 IPv6_DEVICE_PATH
*IPv6
;
1537 RemoteIPStr
= GetNextParamStr (&TextDeviceNode
);
1538 ProtocolStr
= GetNextParamStr (&TextDeviceNode
);
1539 TypeStr
= GetNextParamStr (&TextDeviceNode
);
1540 LocalIPStr
= GetNextParamStr (&TextDeviceNode
);
1541 IPv6
= (IPv6_DEVICE_PATH
*) CreateDeviceNode (
1542 MESSAGING_DEVICE_PATH
,
1544 sizeof (IPv6_DEVICE_PATH
)
1547 StrToIPv6Addr (&RemoteIPStr
, &IPv6
->RemoteIpAddress
);
1548 IPv6
->Protocol
= (StrCmp (ProtocolStr
, L
"UDP") == 0) ? (UINT16
) 0 : (UINT16
) 1;
1549 if (StrCmp (TypeStr
, L
"Static") == 0) {
1550 IPv6
->StaticIpAddress
= TRUE
;
1552 IPv6
->StaticIpAddress
= FALSE
;
1555 StrToIPv6Addr (&LocalIPStr
, &IPv6
->LocalIpAddress
);
1557 IPv6
->LocalPort
= 0;
1558 IPv6
->RemotePort
= 0;
1560 return (EFI_DEVICE_PATH_PROTOCOL
*) IPv6
;
1563 EFI_DEVICE_PATH_PROTOCOL
*
1564 DevPathFromTextUart (
1565 IN CHAR16
*TextDeviceNode
1569 CHAR16
*DataBitsStr
;
1571 CHAR16
*StopBitsStr
;
1572 UART_DEVICE_PATH
*Uart
;
1574 BaudStr
= GetNextParamStr (&TextDeviceNode
);
1575 DataBitsStr
= GetNextParamStr (&TextDeviceNode
);
1576 ParityStr
= GetNextParamStr (&TextDeviceNode
);
1577 StopBitsStr
= GetNextParamStr (&TextDeviceNode
);
1578 Uart
= (UART_DEVICE_PATH
*) CreateDeviceNode (
1579 MESSAGING_DEVICE_PATH
,
1581 sizeof (UART_DEVICE_PATH
)
1584 Uart
->BaudRate
= (StrCmp (BaudStr
, L
"DEFAULT") == 0) ? 115200 : Atoi (BaudStr
);
1585 Uart
->DataBits
= (StrCmp (DataBitsStr
, L
"DEFAULT") == 0) ? (UINT8
) 8 : (UINT8
) Atoi (DataBitsStr
);
1586 switch (*ParityStr
) {
1611 Uart
->Parity
= 0xff;
1614 if (StrCmp (StopBitsStr
, L
"D") == 0) {
1615 Uart
->StopBits
= (UINT8
) 0;
1616 } else if (StrCmp (StopBitsStr
, L
"1") == 0) {
1617 Uart
->StopBits
= (UINT8
) 1;
1618 } else if (StrCmp (StopBitsStr
, L
"1.5") == 0) {
1619 Uart
->StopBits
= (UINT8
) 2;
1620 } else if (StrCmp (StopBitsStr
, L
"2") == 0) {
1621 Uart
->StopBits
= (UINT8
) 3;
1623 Uart
->StopBits
= 0xff;
1626 return (EFI_DEVICE_PATH_PROTOCOL
*) Uart
;
1629 EFI_DEVICE_PATH_PROTOCOL
*
1630 ConvertFromTextUsbClass (
1631 IN CHAR16
*TextDeviceNode
,
1632 IN USB_CLASS_TEXT
*UsbClassText
1638 CHAR16
*SubClassStr
;
1639 CHAR16
*ProtocolStr
;
1640 USB_CLASS_DEVICE_PATH
*UsbClass
;
1642 UsbClass
= (USB_CLASS_DEVICE_PATH
*) CreateDeviceNode (
1643 MESSAGING_DEVICE_PATH
,
1645 sizeof (USB_CLASS_DEVICE_PATH
)
1648 VIDStr
= GetNextParamStr (&TextDeviceNode
);
1649 PIDStr
= GetNextParamStr (&TextDeviceNode
);
1650 if (UsbClassText
->ClassExist
) {
1651 ClassStr
= GetNextParamStr (&TextDeviceNode
);
1652 UsbClass
->DeviceClass
= (UINT8
) Xtoi (ClassStr
);
1654 UsbClass
->DeviceClass
= UsbClassText
->Class
;
1656 if (UsbClassText
->SubClassExist
) {
1657 SubClassStr
= GetNextParamStr (&TextDeviceNode
);
1658 UsbClass
->DeviceSubClass
= (UINT8
) Xtoi (SubClassStr
);
1660 UsbClass
->DeviceSubClass
= UsbClassText
->SubClass
;
1663 ProtocolStr
= GetNextParamStr (&TextDeviceNode
);
1665 UsbClass
->VendorId
= (UINT16
) Xtoi (VIDStr
);
1666 UsbClass
->ProductId
= (UINT16
) Xtoi (PIDStr
);
1667 UsbClass
->DeviceProtocol
= (UINT8
) Xtoi (ProtocolStr
);
1669 return (EFI_DEVICE_PATH_PROTOCOL
*) UsbClass
;
1673 EFI_DEVICE_PATH_PROTOCOL
*
1674 DevPathFromTextUsbClass (
1675 IN CHAR16
*TextDeviceNode
1678 USB_CLASS_TEXT UsbClassText
;
1680 UsbClassText
.ClassExist
= TRUE
;
1681 UsbClassText
.SubClassExist
= TRUE
;
1683 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1686 EFI_DEVICE_PATH_PROTOCOL
*
1687 DevPathFromTextUsbAudio (
1688 IN CHAR16
*TextDeviceNode
1691 USB_CLASS_TEXT UsbClassText
;
1693 UsbClassText
.ClassExist
= FALSE
;
1694 UsbClassText
.Class
= USB_CLASS_AUDIO
;
1695 UsbClassText
.SubClassExist
= TRUE
;
1697 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1700 EFI_DEVICE_PATH_PROTOCOL
*
1701 DevPathFromTextUsbCDCControl (
1702 IN CHAR16
*TextDeviceNode
1705 USB_CLASS_TEXT UsbClassText
;
1707 UsbClassText
.ClassExist
= FALSE
;
1708 UsbClassText
.Class
= USB_CLASS_CDCCONTROL
;
1709 UsbClassText
.SubClassExist
= TRUE
;
1711 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1714 EFI_DEVICE_PATH_PROTOCOL
*
1715 DevPathFromTextUsbHID (
1716 IN CHAR16
*TextDeviceNode
1719 USB_CLASS_TEXT UsbClassText
;
1721 UsbClassText
.ClassExist
= FALSE
;
1722 UsbClassText
.Class
= USB_CLASS_HID
;
1723 UsbClassText
.SubClassExist
= TRUE
;
1725 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1728 EFI_DEVICE_PATH_PROTOCOL
*
1729 DevPathFromTextUsbImage (
1730 IN CHAR16
*TextDeviceNode
1733 USB_CLASS_TEXT UsbClassText
;
1735 UsbClassText
.ClassExist
= FALSE
;
1736 UsbClassText
.Class
= USB_CLASS_IMAGE
;
1737 UsbClassText
.SubClassExist
= TRUE
;
1739 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1742 EFI_DEVICE_PATH_PROTOCOL
*
1743 DevPathFromTextUsbPrinter (
1744 IN CHAR16
*TextDeviceNode
1747 USB_CLASS_TEXT UsbClassText
;
1749 UsbClassText
.ClassExist
= FALSE
;
1750 UsbClassText
.Class
= USB_CLASS_PRINTER
;
1751 UsbClassText
.SubClassExist
= TRUE
;
1753 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1756 EFI_DEVICE_PATH_PROTOCOL
*
1757 DevPathFromTextUsbMassStorage (
1758 IN CHAR16
*TextDeviceNode
1761 USB_CLASS_TEXT UsbClassText
;
1763 UsbClassText
.ClassExist
= FALSE
;
1764 UsbClassText
.Class
= USB_CLASS_MASS_STORAGE
;
1765 UsbClassText
.SubClassExist
= TRUE
;
1767 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1770 EFI_DEVICE_PATH_PROTOCOL
*
1771 DevPathFromTextUsbHub (
1772 IN CHAR16
*TextDeviceNode
1775 USB_CLASS_TEXT UsbClassText
;
1777 UsbClassText
.ClassExist
= FALSE
;
1778 UsbClassText
.Class
= USB_CLASS_HUB
;
1779 UsbClassText
.SubClassExist
= TRUE
;
1781 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1784 EFI_DEVICE_PATH_PROTOCOL
*
1785 DevPathFromTextUsbCDCData (
1786 IN CHAR16
*TextDeviceNode
1789 USB_CLASS_TEXT UsbClassText
;
1791 UsbClassText
.ClassExist
= FALSE
;
1792 UsbClassText
.Class
= USB_CLASS_CDCDATA
;
1793 UsbClassText
.SubClassExist
= TRUE
;
1795 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1798 EFI_DEVICE_PATH_PROTOCOL
*
1799 DevPathFromTextUsbSmartCard (
1800 IN CHAR16
*TextDeviceNode
1803 USB_CLASS_TEXT UsbClassText
;
1805 UsbClassText
.ClassExist
= FALSE
;
1806 UsbClassText
.Class
= USB_CLASS_SMART_CARD
;
1807 UsbClassText
.SubClassExist
= TRUE
;
1809 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1812 EFI_DEVICE_PATH_PROTOCOL
*
1813 DevPathFromTextUsbVideo (
1814 IN CHAR16
*TextDeviceNode
1817 USB_CLASS_TEXT UsbClassText
;
1819 UsbClassText
.ClassExist
= FALSE
;
1820 UsbClassText
.Class
= USB_CLASS_VIDEO
;
1821 UsbClassText
.SubClassExist
= TRUE
;
1823 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1826 EFI_DEVICE_PATH_PROTOCOL
*
1827 DevPathFromTextUsbDiagnostic (
1828 IN CHAR16
*TextDeviceNode
1831 USB_CLASS_TEXT UsbClassText
;
1833 UsbClassText
.ClassExist
= FALSE
;
1834 UsbClassText
.Class
= USB_CLASS_DIAGNOSTIC
;
1835 UsbClassText
.SubClassExist
= TRUE
;
1837 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1840 EFI_DEVICE_PATH_PROTOCOL
*
1841 DevPathFromTextUsbWireless (
1842 IN CHAR16
*TextDeviceNode
1845 USB_CLASS_TEXT UsbClassText
;
1847 UsbClassText
.ClassExist
= FALSE
;
1848 UsbClassText
.Class
= USB_CLASS_WIRELESS
;
1849 UsbClassText
.SubClassExist
= TRUE
;
1851 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1854 EFI_DEVICE_PATH_PROTOCOL
*
1855 DevPathFromTextUsbDeviceFirmwareUpdate (
1856 IN CHAR16
*TextDeviceNode
1859 USB_CLASS_TEXT UsbClassText
;
1861 UsbClassText
.ClassExist
= FALSE
;
1862 UsbClassText
.Class
= USB_CLASS_RESERVE
;
1863 UsbClassText
.SubClassExist
= FALSE
;
1864 UsbClassText
.SubClass
= USB_SUBCLASS_FW_UPDATE
;
1866 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1869 EFI_DEVICE_PATH_PROTOCOL
*
1870 DevPathFromTextUsbIrdaBridge (
1871 IN CHAR16
*TextDeviceNode
1874 USB_CLASS_TEXT UsbClassText
;
1876 UsbClassText
.ClassExist
= FALSE
;
1877 UsbClassText
.Class
= USB_CLASS_RESERVE
;
1878 UsbClassText
.SubClassExist
= FALSE
;
1879 UsbClassText
.SubClass
= USB_SUBCLASS_IRDA_BRIDGE
;
1881 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1884 EFI_DEVICE_PATH_PROTOCOL
*
1885 DevPathFromTextUsbTestAndMeasurement (
1886 IN CHAR16
*TextDeviceNode
1889 USB_CLASS_TEXT UsbClassText
;
1891 UsbClassText
.ClassExist
= FALSE
;
1892 UsbClassText
.Class
= USB_CLASS_RESERVE
;
1893 UsbClassText
.SubClassExist
= FALSE
;
1894 UsbClassText
.SubClass
= USB_SUBCLASS_TEST
;
1896 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1899 EFI_DEVICE_PATH_PROTOCOL
*
1900 DevPathFromTextUsbWwid (
1901 IN CHAR16
*TextDeviceNode
1906 CHAR16
*InterfaceNumStr
;
1907 USB_WWID_DEVICE_PATH
*UsbWwid
;
1909 VIDStr
= GetNextParamStr (&TextDeviceNode
);
1910 PIDStr
= GetNextParamStr (&TextDeviceNode
);
1911 InterfaceNumStr
= GetNextParamStr (&TextDeviceNode
);
1912 UsbWwid
= (USB_WWID_DEVICE_PATH
*) CreateDeviceNode (
1913 MESSAGING_DEVICE_PATH
,
1915 sizeof (USB_WWID_DEVICE_PATH
)
1918 UsbWwid
->VendorId
= (UINT16
) Xtoi (VIDStr
);
1919 UsbWwid
->ProductId
= (UINT16
) Xtoi (PIDStr
);
1920 UsbWwid
->InterfaceNumber
= (UINT16
) Xtoi (InterfaceNumStr
);
1922 return (EFI_DEVICE_PATH_PROTOCOL
*) UsbWwid
;
1925 EFI_DEVICE_PATH_PROTOCOL
*
1926 DevPathFromTextUnit (
1927 IN CHAR16
*TextDeviceNode
1931 DEVICE_LOGICAL_UNIT_DEVICE_PATH
*LogicalUnit
;
1933 LunStr
= GetNextParamStr (&TextDeviceNode
);
1934 LogicalUnit
= (DEVICE_LOGICAL_UNIT_DEVICE_PATH
*) CreateDeviceNode (
1935 MESSAGING_DEVICE_PATH
,
1936 MSG_DEVICE_LOGICAL_UNIT_DP
,
1937 sizeof (DEVICE_LOGICAL_UNIT_DEVICE_PATH
)
1940 LogicalUnit
->Lun
= (UINT8
) Xtoi (LunStr
);
1942 return (EFI_DEVICE_PATH_PROTOCOL
*) LogicalUnit
;
1945 EFI_DEVICE_PATH_PROTOCOL
*
1946 DevPathFromTextiSCSI (
1947 IN CHAR16
*TextDeviceNode
1952 CHAR16
*PortalGroupStr
;
1954 CHAR16
*HeaderDigestStr
;
1955 CHAR16
*DataDigestStr
;
1956 CHAR16
*AuthenticationStr
;
1957 CHAR16
*ProtocolStr
;
1958 ISCSI_DEVICE_PATH_WITH_NAME
*iSCSI
;
1960 NameStr
= GetNextParamStr (&TextDeviceNode
);
1961 PortalGroupStr
= GetNextParamStr (&TextDeviceNode
);
1962 LunStr
= GetNextParamStr (&TextDeviceNode
);
1963 HeaderDigestStr
= GetNextParamStr (&TextDeviceNode
);
1964 DataDigestStr
= GetNextParamStr (&TextDeviceNode
);
1965 AuthenticationStr
= GetNextParamStr (&TextDeviceNode
);
1966 ProtocolStr
= GetNextParamStr (&TextDeviceNode
);
1967 iSCSI
= (ISCSI_DEVICE_PATH_WITH_NAME
*) CreateDeviceNode (
1968 MESSAGING_DEVICE_PATH
,
1970 sizeof (ISCSI_DEVICE_PATH_WITH_NAME
) + (UINT16
) (StrLen (NameStr
) * 2)
1973 StrCpy (iSCSI
->iSCSITargetName
, NameStr
);
1974 iSCSI
->TargetPortalGroupTag
= (UINT16
) Xtoi (PortalGroupStr
);
1975 Xtoi64 (LunStr
, &iSCSI
->Lun
);
1978 if (StrCmp (HeaderDigestStr
, L
"CRC32C") == 0) {
1982 if (StrCmp (DataDigestStr
, L
"CRC32C") == 0) {
1986 if (StrCmp (AuthenticationStr
, L
"None") == 0) {
1990 if (StrCmp (AuthenticationStr
, L
"CHAP_UNI") == 0) {
1994 iSCSI
->LoginOption
= (UINT16
) Options
;
1996 iSCSI
->NetworkProtocol
= (UINT16
) StrCmp (ProtocolStr
, L
"TCP");
1997 iSCSI
->Reserved
= (UINT16
) 0;
1999 return (EFI_DEVICE_PATH_PROTOCOL
*) iSCSI
;
2002 EFI_DEVICE_PATH_PROTOCOL
*
2004 IN CHAR16
*TextDeviceNode
2007 CHAR16
*PartitionStr
;
2009 CHAR16
*SignatureStr
;
2013 EFI_GUID SignatureGuid
;
2014 HARDDRIVE_DEVICE_PATH
*Hd
;
2016 PartitionStr
= GetNextParamStr (&TextDeviceNode
);
2017 TypeStr
= GetNextParamStr (&TextDeviceNode
);
2018 SignatureStr
= GetNextParamStr (&TextDeviceNode
);
2019 StartStr
= GetNextParamStr (&TextDeviceNode
);
2020 SizeStr
= GetNextParamStr (&TextDeviceNode
);
2021 Hd
= (HARDDRIVE_DEVICE_PATH
*) CreateDeviceNode (
2024 sizeof (HARDDRIVE_DEVICE_PATH
)
2027 Hd
->PartitionNumber
= (UINT32
) Atoi (PartitionStr
);
2029 ZeroMem (Hd
->Signature
, 16);
2030 Hd
->MBRType
= (UINT8
) 0;
2032 if (StrCmp (TypeStr
, L
"None") == 0) {
2033 Hd
->SignatureType
= (UINT8
) 0;
2034 } else if (StrCmp (TypeStr
, L
"MBR") == 0) {
2035 Hd
->SignatureType
= SIGNATURE_TYPE_MBR
;
2038 Signature32
= (UINT32
) Xtoi (SignatureStr
);
2039 CopyMem (Hd
->Signature
, &Signature32
, sizeof (UINT32
));
2040 } else if (StrCmp (TypeStr
, L
"GUID") == 0) {
2041 Hd
->SignatureType
= SIGNATURE_TYPE_GUID
;
2044 StrToGuid (SignatureStr
, &SignatureGuid
);
2045 CopyMem (Hd
->Signature
, &SignatureGuid
, sizeof (EFI_GUID
));
2047 Hd
->SignatureType
= 0xff;
2051 Xtoi64 (StartStr
, &Hd
->PartitionStart
);
2052 Xtoi64 (SizeStr
, &Hd
->PartitionSize
);
2054 return (EFI_DEVICE_PATH_PROTOCOL
*) Hd
;
2057 EFI_DEVICE_PATH_PROTOCOL
*
2058 DevPathFromTextCDROM (
2059 IN CHAR16
*TextDeviceNode
2065 CDROM_DEVICE_PATH
*CDROM
;
2067 EntryStr
= GetNextParamStr (&TextDeviceNode
);
2068 StartStr
= GetNextParamStr (&TextDeviceNode
);
2069 SizeStr
= GetNextParamStr (&TextDeviceNode
);
2070 CDROM
= (CDROM_DEVICE_PATH
*) CreateDeviceNode (
2073 sizeof (CDROM_DEVICE_PATH
)
2076 CDROM
->BootEntry
= (UINT32
) Xtoi (EntryStr
);
2077 Xtoi64 (StartStr
, &CDROM
->PartitionStart
);
2078 Xtoi64 (SizeStr
, &CDROM
->PartitionSize
);
2080 return (EFI_DEVICE_PATH_PROTOCOL
*) CDROM
;
2083 EFI_DEVICE_PATH_PROTOCOL
*
2084 DevPathFromTextVenMEDIA (
2085 IN CHAR16
*TextDeviceNode
2088 return ConvertFromTextVendor (
2095 EFI_DEVICE_PATH_PROTOCOL
*
2096 DevPathFromTextFilePath (
2097 IN CHAR16
*TextDeviceNode
2100 FILEPATH_DEVICE_PATH
*File
;
2102 File
= (FILEPATH_DEVICE_PATH
*) CreateDeviceNode (
2105 sizeof (FILEPATH_DEVICE_PATH
) + (UINT16
) (StrLen (TextDeviceNode
) * 2)
2108 StrCpy (File
->PathName
, TextDeviceNode
);
2110 return (EFI_DEVICE_PATH_PROTOCOL
*) File
;
2113 EFI_DEVICE_PATH_PROTOCOL
*
2114 DevPathFromTextMedia (
2115 IN CHAR16
*TextDeviceNode
2119 MEDIA_PROTOCOL_DEVICE_PATH
*Media
;
2121 GuidStr
= GetNextParamStr (&TextDeviceNode
);
2122 Media
= (MEDIA_PROTOCOL_DEVICE_PATH
*) CreateDeviceNode (
2125 sizeof (MEDIA_PROTOCOL_DEVICE_PATH
)
2128 StrToGuid (GuidStr
, &Media
->Protocol
);
2130 return (EFI_DEVICE_PATH_PROTOCOL
*) Media
;
2133 EFI_DEVICE_PATH_PROTOCOL
*
2134 DevPathFromTextBBS (
2135 IN CHAR16
*TextDeviceNode
2142 BBS_BBS_DEVICE_PATH
*Bbs
;
2144 TypeStr
= GetNextParamStr (&TextDeviceNode
);
2145 IdStr
= GetNextParamStr (&TextDeviceNode
);
2146 FlagsStr
= GetNextParamStr (&TextDeviceNode
);
2147 Bbs
= (BBS_BBS_DEVICE_PATH
*) CreateDeviceNode (
2150 sizeof (BBS_BBS_DEVICE_PATH
) + (UINT16
) (StrLen (IdStr
))
2153 if (StrCmp (TypeStr
, L
"Floppy") == 0) {
2154 Bbs
->DeviceType
= BBS_TYPE_FLOPPY
;
2155 } else if (StrCmp (TypeStr
, L
"HD") == 0) {
2156 Bbs
->DeviceType
= BBS_TYPE_HARDDRIVE
;
2157 } else if (StrCmp (TypeStr
, L
"CDROM") == 0) {
2158 Bbs
->DeviceType
= BBS_TYPE_CDROM
;
2159 } else if (StrCmp (TypeStr
, L
"PCMCIA") == 0) {
2160 Bbs
->DeviceType
= BBS_TYPE_PCMCIA
;
2161 } else if (StrCmp (TypeStr
, L
"USB") == 0) {
2162 Bbs
->DeviceType
= BBS_TYPE_USB
;
2163 } else if (StrCmp (TypeStr
, L
"Network") == 0) {
2164 Bbs
->DeviceType
= BBS_TYPE_EMBEDDED_NETWORK
;
2166 Bbs
->DeviceType
= BBS_TYPE_UNKNOWN
;
2169 AsciiStr
= (UINT8
*) Bbs
->String
;
2170 StrToAscii (IdStr
, (CHAR8
**) &AsciiStr
);
2172 Bbs
->StatusFlag
= (UINT16
) Xtoi (FlagsStr
);
2174 return (EFI_DEVICE_PATH_PROTOCOL
*) Bbs
;
2177 DEVICE_PATH_FROM_TEXT_TABLE DevPathFromTextTable
[] = {
2178 {L
"Pci", DevPathFromTextPci
},
2179 {L
"PcCard", DevPathFromTextPcCard
},
2180 {L
"MemoryMapped", DevPathFromTextMemoryMapped
},
2181 {L
"VenHw", DevPathFromTextVenHw
},
2182 {L
"Ctrl", DevPathFromTextCtrl
},
2183 {L
"Acpi", DevPathFromTextAcpi
},
2184 {L
"PciRoot", DevPathFromTextPciRoot
},
2185 {L
"Floppy", DevPathFromTextFloppy
},
2186 {L
"Keyboard", DevPathFromTextKeyboard
},
2187 {L
"Serial", DevPathFromTextSerial
},
2188 {L
"ParallelPort", DevPathFromTextParallelPort
},
2189 {L
"AcpiEx", DevPathFromTextAcpiEx
},
2190 {L
"AcpiExp", DevPathFromTextAcpiExp
},
2191 {L
"Ata", DevPathFromTextAta
},
2192 {L
"Scsi", DevPathFromTextScsi
},
2193 {L
"Fibre", DevPathFromTextFibre
},
2194 {L
"I1394", DevPathFromText1394
},
2195 {L
"USB", DevPathFromTextUsb
},
2196 {L
"I2O", DevPathFromTextI2O
},
2197 {L
"Infiniband", DevPathFromTextInfiniband
},
2198 {L
"VenMsg", DevPathFromTextVenMsg
},
2199 {L
"VenPcAnsi", DevPathFromTextVenPcAnsi
},
2200 {L
"VenVt100", DevPathFromTextVenVt100
},
2201 {L
"VenVt100Plus", DevPathFromTextVenVt100Plus
},
2202 {L
"VenUtf8", DevPathFromTextVenUtf8
},
2203 {L
"UartFlowCtrl", DevPathFromTextUartFlowCtrl
},
2204 {L
"SAS", DevPathFromTextSAS
},
2205 {L
"DebugPort", DevPathFromTextDebugPort
},
2206 {L
"MAC", DevPathFromTextMAC
},
2207 {L
"IPv4", DevPathFromTextIPv4
},
2208 {L
"IPv6", DevPathFromTextIPv6
},
2209 {L
"Uart", DevPathFromTextUart
},
2210 {L
"UsbClass", DevPathFromTextUsbClass
},
2211 {L
"UsbAudio", DevPathFromTextUsbAudio
},
2212 {L
"UsbCDCControl", DevPathFromTextUsbCDCControl
},
2213 {L
"UsbHID", DevPathFromTextUsbHID
},
2214 {L
"UsbImage", DevPathFromTextUsbImage
},
2215 {L
"UsbPrinter", DevPathFromTextUsbPrinter
},
2216 {L
"UsbMassStorage", DevPathFromTextUsbMassStorage
},
2217 {L
"UsbHub", DevPathFromTextUsbHub
},
2218 {L
"UsbCDCData", DevPathFromTextUsbCDCData
},
2219 {L
"UsbSmartCard", DevPathFromTextUsbSmartCard
},
2220 {L
"UsbVideo", DevPathFromTextUsbVideo
},
2221 {L
"UsbDiagnostic", DevPathFromTextUsbDiagnostic
},
2222 {L
"UsbWireless", DevPathFromTextUsbWireless
},
2223 {L
"UsbDeviceFirmwareUpdate", DevPathFromTextUsbDeviceFirmwareUpdate
},
2224 {L
"UsbIrdaBridge", DevPathFromTextUsbIrdaBridge
},
2225 {L
"UsbTestAndMeasurement", DevPathFromTextUsbTestAndMeasurement
},
2226 {L
"UsbWwid", DevPathFromTextUsbWwid
},
2227 {L
"Unit", DevPathFromTextUnit
},
2228 {L
"iSCSI", DevPathFromTextiSCSI
},
2229 {L
"HD", DevPathFromTextHD
},
2230 {L
"CDROM", DevPathFromTextCDROM
},
2231 {L
"VenMEDIA", DevPathFromTextVenMEDIA
},
2232 {L
"Media", DevPathFromTextMedia
},
2233 {L
"BBS", DevPathFromTextBBS
},
2237 EFI_DEVICE_PATH_PROTOCOL
*
2238 ConvertTextToDeviceNode (
2239 IN CONST CHAR16
*TextDeviceNode
2243 Routine Description:
2244 Convert text to the binary representation of a device node.
2247 TextDeviceNode - TextDeviceNode points to the text representation of a device
2248 node. Conversion starts with the first character and continues
2249 until the first non-device node character.
2252 A pointer - Pointer to the EFI device node.
2253 NULL - If TextDeviceNode is NULL or there was insufficient memory or text unsupported.
2257 EFI_DEVICE_PATH_PROTOCOL
* (*DumpNode
) (CHAR16
*);
2259 EFI_DEVICE_PATH_PROTOCOL
*DeviceNode
;
2260 CHAR16
*DeviceNodeStr
;
2263 if ((TextDeviceNode
== NULL
) || (IS_NULL (*TextDeviceNode
))) {
2269 DeviceNodeStr
= StrDuplicate (TextDeviceNode
);
2271 for (Index
= 0; DevPathFromTextTable
[Index
].Function
; Index
++) {
2272 ParamStr
= GetParamByNodeName (DeviceNodeStr
, DevPathFromTextTable
[Index
].DevicePathNodeText
);
2273 if (ParamStr
!= NULL
) {
2274 DumpNode
= DevPathFromTextTable
[Index
].Function
;
2279 if (DumpNode
== NULL
) {
2283 DumpNode
= DevPathFromTextFilePath
;
2284 DeviceNode
= DumpNode (DeviceNodeStr
);
2286 DeviceNode
= DumpNode (ParamStr
);
2287 gBS
->FreePool (ParamStr
);
2290 gBS
->FreePool (DeviceNodeStr
);
2295 EFI_DEVICE_PATH_PROTOCOL
*
2296 ConvertTextToDevicePath (
2297 IN CONST CHAR16
*TextDevicePath
2301 Routine Description:
2302 Convert text to the binary representation of a device path.
2305 TextDevicePath - TextDevicePath points to the text representation of a device
2306 path. Conversion starts with the first character and continues
2307 until the first non-device node character.
2310 A pointer - Pointer to the allocated device path.
2311 NULL - If TextDeviceNode is NULL or there was insufficient memory.
2315 EFI_DEVICE_PATH_PROTOCOL
* (*DumpNode
) (CHAR16
*);
2317 EFI_DEVICE_PATH_PROTOCOL
*DeviceNode
;
2319 EFI_DEVICE_PATH_PROTOCOL
*NewDevicePath
;
2320 CHAR16
*DevicePathStr
;
2322 CHAR16
*DeviceNodeStr
;
2323 UINT8 IsInstanceEnd
;
2324 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
2326 if ((TextDevicePath
== NULL
) || (IS_NULL (*TextDevicePath
))) {
2330 DevicePath
= (EFI_DEVICE_PATH_PROTOCOL
*) AllocatePool (END_DEVICE_PATH_LENGTH
);
2331 SetDevicePathEndNode (DevicePath
);
2334 DeviceNodeStr
= NULL
;
2335 DevicePathStr
= StrDuplicate (TextDevicePath
);
2337 Str
= DevicePathStr
;
2338 while ((DeviceNodeStr
= GetNextDeviceNodeStr (&Str
, &IsInstanceEnd
)) != NULL
) {
2340 for (Index
= 0; DevPathFromTextTable
[Index
].Function
; Index
++) {
2341 ParamStr
= GetParamByNodeName (DeviceNodeStr
, DevPathFromTextTable
[Index
].DevicePathNodeText
);
2342 if (ParamStr
!= NULL
) {
2343 DumpNode
= DevPathFromTextTable
[Index
].Function
;
2348 if (DumpNode
== NULL
) {
2352 DumpNode
= DevPathFromTextFilePath
;
2353 DeviceNode
= DumpNode (DeviceNodeStr
);
2355 DeviceNode
= DumpNode (ParamStr
);
2356 gBS
->FreePool (ParamStr
);
2359 NewDevicePath
= AppendDeviceNodeProtocolInterface (DevicePath
, DeviceNode
);
2360 gBS
->FreePool (DevicePath
);
2361 gBS
->FreePool (DeviceNode
);
2362 DevicePath
= NewDevicePath
;
2364 if (IsInstanceEnd
) {
2365 DeviceNode
= (EFI_DEVICE_PATH_PROTOCOL
*) AllocatePool (END_DEVICE_PATH_LENGTH
);
2366 SetDevicePathInstanceEndNode (DeviceNode
);
2368 NewDevicePath
= AppendDeviceNodeProtocolInterface (DevicePath
, DeviceNode
);
2369 gBS
->FreePool (DevicePath
);
2370 gBS
->FreePool (DeviceNode
);
2371 DevicePath
= NewDevicePath
;
2375 gBS
->FreePool (DevicePathStr
);