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 <protocol/DevicePathFromText.h>
23 #include "DevicePath.h"
45 Length
= StrLen ((CHAR16
*) Src
);
47 ReturnStr
= AllocateCopyPool ((Length
+ 1) * sizeof (CHAR16
), (VOID
*) Src
);
60 Get parameter in a pair of parentheses follow the given node name.
61 For example, given the "Pci(0,1)" and NodeName "Pci", it returns "0,1".
64 Str - Device Path Text
65 NodeName - Name of the node
68 Parameter text for the node
75 UINTN ParameterLength
;
78 // Check whether the node name matchs
80 NodeNameLength
= StrLen (NodeName
);
81 if (CompareMem (Str
, NodeName
, NodeNameLength
* sizeof (CHAR16
)) != 0) {
85 ParamStr
= Str
+ NodeNameLength
;
86 if (!IS_LEFT_PARENTH (*ParamStr
)) {
91 // Skip the found '(' and find first occurrence of ')'
95 StrPointer
= ParamStr
;
96 while (!IS_NULL (*StrPointer
)) {
97 if (IS_RIGHT_PARENTH (*StrPointer
)) {
103 if (IS_NULL (*StrPointer
)) {
110 ParamStr
= AllocateCopyPool ((ParameterLength
+ 1) * sizeof (CHAR16
), ParamStr
);
111 if (ParamStr
== NULL
) {
115 // Terminate the parameter string
117 ParamStr
[ParameterLength
] = L
'\0';
124 IN OUT CHAR16
**List
,
130 Get current sub-string from a string list, before return
131 the list header is moved to next sub-string. The sub-string is separated
132 by the specified character. For example, the separator is ',', the string
133 list is "2,0,3", it returns "2", the remain list move to "2,3"
136 List - A string list separated by the specified separator
137 Separator - The separator character
140 pointer - The current sub-string
150 if (IS_NULL (*Str
)) {
155 // Find first occurrence of the separator
157 while (!IS_NULL (*Str
)) {
158 if (*Str
== Separator
) {
164 if (*Str
== Separator
) {
166 // Find a sub-string, terminate it
173 // Move to next sub-string
186 // The separator is comma
188 return SplitStr (List
, L
',');
192 GetNextDeviceNodeStr (
193 IN OUT CHAR16
**DevicePath
,
194 OUT BOOLEAN
*IsInstanceEnd
199 Get one device node from entire device path text.
202 Str - The entire device path text string
203 IsInstanceEnd - This node is the end of a device path instance
206 a pointer - A device node text
207 NULL - No more device node available
213 UINTN ParenthesesStack
;
216 if (IS_NULL (*Str
)) {
221 // Skip the leading '/', '(', ')' and ','
223 while (!IS_NULL (*Str
)) {
224 if (!IS_SLASH (*Str
) &&
226 !IS_LEFT_PARENTH (*Str
) &&
227 !IS_RIGHT_PARENTH (*Str
)) {
236 // Scan for the separator of this device node, '/' or ','
238 ParenthesesStack
= 0;
239 while (!IS_NULL (*Str
)) {
240 if ((IS_COMMA (*Str
) || IS_SLASH (*Str
)) && (ParenthesesStack
== 0)) {
244 if (IS_LEFT_PARENTH (*Str
)) {
246 } else if (IS_RIGHT_PARENTH (*Str
)) {
253 if (ParenthesesStack
!= 0) {
255 // The '(' doesn't pair with ')', invalid device path text
260 if (IS_COMMA (*Str
)) {
261 *IsInstanceEnd
= TRUE
;
265 *IsInstanceEnd
= FALSE
;
266 if (!IS_NULL (*Str
)) {
285 Determines if a Unicode character is a hexadecimal digit.
286 The test is case insensitive.
289 Digit - Pointer to byte that receives the value of the hex character.
290 Char - Unicode character to test.
293 TRUE - If the character is a hexadecimal digit.
298 if ((Char
>= L
'0') && (Char
<= L
'9')) {
299 *Digit
= (UINT8
) (Char
- L
'0');
303 if ((Char
>= L
'A') && (Char
<= L
'F')) {
304 *Digit
= (UINT8
) (Char
- L
'A' + 0x0A);
308 if ((Char
>= L
'a') && (Char
<= L
'f')) {
309 *Digit
= (UINT8
) (Char
- L
'a' + 0x0A);
323 Converts the low nibble of a byte to hex unicode character.
326 Nibble - lower nibble of a byte.
329 Hex unicode character.
335 return (CHAR16
)(Nibble
+ L
'0');
338 return (CHAR16
)(Nibble
- 0xA + L
'A');
346 OUT UINTN
*ConvertedStrLen OPTIONAL
351 Converts Unicode string to binary buffer.
352 The conversion may be partial.
353 The first character in the string that is not hex digit stops the conversion.
354 At a minimum, any blob of data could be represented as a hex string.
357 Buf - Pointer to buffer that receives the data.
358 Len - Length in bytes of the buffer to hold converted data.
359 If routine return with EFI_SUCCESS, containing length of converted data.
360 If routine return with EFI_BUFFER_TOO_SMALL, containg length of buffer desired.
361 Str - String to be converted from.
362 ConvertedStrLen - Length of the Hex String consumed.
365 EFI_SUCCESS: Routine Success.
366 EFI_BUFFER_TOO_SMALL: The buffer is too small to hold converted data.
378 // Find out how many hex characters the string has.
380 for (Idx
= 0, HexCnt
= 0; IsHexDigit (&Digit
, Str
[Idx
]); Idx
++, HexCnt
++);
387 // Two Unicode characters make up 1 buffer byte. Round up.
389 BufferLength
= (HexCnt
+ 1) / 2;
392 // Test if buffer is passed enough.
394 if (BufferLength
> (*Len
)) {
396 return EFI_BUFFER_TOO_SMALL
;
401 for (Idx
= 0; Idx
< HexCnt
; Idx
++) {
403 IsHexDigit (&Digit
, Str
[HexCnt
- 1 - Idx
]);
406 // For odd charaters, write the lower nibble for each buffer byte,
407 // and for even characters, the upper nibble.
409 if ((Idx
& 1) == 0) {
420 if (ConvertedStrLen
!= NULL
) {
421 *ConvertedStrLen
= HexCnt
;
430 IN OUT UINTN
*HexStringBufferLength
,
437 Converts binary buffer to Unicode string.
438 At a minimum, any blob of data could be represented as a hex string.
441 Str - Pointer to the string.
442 HexStringBufferLength - Length in bytes of buffer to hold the hex string. Includes tailing '\0' character.
443 If routine return with EFI_SUCCESS, containing length of hex string buffer.
444 If routine return with EFI_BUFFER_TOO_SMALL, containg length of hex string buffer desired.
445 Buf - Buffer to be converted from.
446 Len - Length in bytes of the buffer to be converted.
449 EFI_SUCCESS: Routine success.
450 EFI_BUFFER_TOO_SMALL: The hex string buffer is too small.
459 // Make sure string is either passed or allocate enough.
460 // It takes 2 Unicode characters (4 bytes) to represent 1 byte of the binary buffer.
461 // Plus the Unicode termination character.
464 if (StrLen
> ((*HexStringBufferLength
) - 1)) {
465 *HexStringBufferLength
= StrLen
+ 1;
466 return EFI_BUFFER_TOO_SMALL
;
469 *HexStringBufferLength
= StrLen
+ 1;
475 for (Idx
= 0; Idx
< Len
; Idx
++) {
478 Str
[StrLen
- 1 - Idx
* 2] = NibbleToHexChar (Byte
);
479 Str
[StrLen
- 2 - Idx
* 2] = NibbleToHexChar ((UINT8
)(Byte
>> 4));
492 Skip the leading white space and '0x' or '0X' of a hex string
502 // skip preceeding white space
504 while (*Str
&& *Str
== ' ') {
508 // skip preceeding zeros
510 while (*Str
&& *Str
== '0') {
514 // skip preceeding white space
516 if (*Str
&& (*Str
== 'x' || *Str
== 'X')) {
531 Convert hex string to uint
544 ASSERT (Str
!= NULL
);
547 // convert hex digits
550 Length
= sizeof (UINTN
);
551 HexStringToBuf ((UINT8
*) &Rvalue
, &Length
, TrimHexStr (Str
), NULL
);
565 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 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 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 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 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 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 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 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
= Bbs
->String
;
2170 StrToAscii (IdStr
, &AsciiStr
);
2172 Bbs
->StatusFlag
= (UINT16
) Xtoi (FlagsStr
);
2174 return (EFI_DEVICE_PATH_PROTOCOL
*) Bbs
;
2177 DEVICE_PATH_FROM_TEXT_TABLE DevPathFromTextTable
[] = {
2181 DevPathFromTextPcCard
,
2183 DevPathFromTextMemoryMapped
,
2185 DevPathFromTextVenHw
,
2187 DevPathFromTextCtrl
,
2189 DevPathFromTextAcpi
,
2191 DevPathFromTextPciRoot
,
2193 DevPathFromTextFloppy
,
2195 DevPathFromTextKeyboard
,
2197 DevPathFromTextSerial
,
2199 DevPathFromTextParallelPort
,
2201 DevPathFromTextAcpiEx
,
2203 DevPathFromTextAcpiExp
,
2207 DevPathFromTextScsi
,
2209 DevPathFromTextFibre
,
2211 DevPathFromText1394
,
2217 DevPathFromTextInfiniband
,
2219 DevPathFromTextVenMsg
,
2221 DevPathFromTextVenPcAnsi
,
2223 DevPathFromTextVenVt100
,
2225 DevPathFromTextVenVt100Plus
,
2227 DevPathFromTextVenUtf8
,
2229 DevPathFromTextUartFlowCtrl
,
2233 DevPathFromTextDebugPort
,
2237 DevPathFromTextIPv4
,
2239 DevPathFromTextIPv6
,
2241 DevPathFromTextUart
,
2243 DevPathFromTextUsbClass
,
2245 DevPathFromTextUsbAudio
,
2247 DevPathFromTextUsbCDCControl
,
2249 DevPathFromTextUsbHID
,
2251 DevPathFromTextUsbImage
,
2253 DevPathFromTextUsbPrinter
,
2255 DevPathFromTextUsbMassStorage
,
2257 DevPathFromTextUsbHub
,
2259 DevPathFromTextUsbCDCData
,
2261 DevPathFromTextUsbSmartCard
,
2263 DevPathFromTextUsbVideo
,
2265 DevPathFromTextUsbDiagnostic
,
2267 DevPathFromTextUsbWireless
,
2268 L
"UsbDeviceFirmwareUpdate",
2269 DevPathFromTextUsbDeviceFirmwareUpdate
,
2271 DevPathFromTextUsbIrdaBridge
,
2272 L
"UsbTestAndMeasurement",
2273 DevPathFromTextUsbTestAndMeasurement
,
2275 DevPathFromTextUsbWwid
,
2277 DevPathFromTextUnit
,
2279 DevPathFromTextiSCSI
,
2283 DevPathFromTextCDROM
,
2285 DevPathFromTextVenMEDIA
,
2287 DevPathFromTextMedia
,
2294 EFI_DEVICE_PATH_PROTOCOL
*
2295 ConvertTextToDeviceNode (
2296 IN CONST CHAR16
*TextDeviceNode
2300 Routine Description:
2301 Convert text to the binary representation of a device node.
2304 TextDeviceNode - TextDeviceNode points to the text representation of a device
2305 node. Conversion starts with the first character and continues
2306 until the first non-device node character.
2309 A pointer - Pointer to the EFI device node.
2310 NULL - If TextDeviceNode is NULL or there was insufficient memory or text unsupported.
2314 EFI_DEVICE_PATH_PROTOCOL
* (*DumpNode
) (CHAR16
*);
2316 EFI_DEVICE_PATH_PROTOCOL
*DeviceNode
;
2317 CHAR16
*DeviceNodeStr
;
2320 if ((TextDeviceNode
== NULL
) || (IS_NULL (*TextDeviceNode
))) {
2326 DeviceNodeStr
= StrDuplicate (TextDeviceNode
);
2328 for (Index
= 0; DevPathFromTextTable
[Index
].Function
; Index
++) {
2329 ParamStr
= GetParamByNodeName (DeviceNodeStr
, DevPathFromTextTable
[Index
].DevicePathNodeText
);
2330 if (ParamStr
!= NULL
) {
2331 DumpNode
= DevPathFromTextTable
[Index
].Function
;
2336 if (DumpNode
== NULL
) {
2340 DumpNode
= DevPathFromTextFilePath
;
2341 DeviceNode
= DumpNode (DeviceNodeStr
);
2343 DeviceNode
= DumpNode (ParamStr
);
2344 gBS
->FreePool (ParamStr
);
2347 gBS
->FreePool (DeviceNodeStr
);
2352 EFI_DEVICE_PATH_PROTOCOL
*
2353 ConvertTextToDevicePath (
2354 IN CONST CHAR16
*TextDevicePath
2358 Routine Description:
2359 Convert text to the binary representation of a device path.
2362 TextDevicePath - TextDevicePath points to the text representation of a device
2363 path. Conversion starts with the first character and continues
2364 until the first non-device node character.
2367 A pointer - Pointer to the allocated device path.
2368 NULL - If TextDeviceNode is NULL or there was insufficient memory.
2372 EFI_DEVICE_PATH_PROTOCOL
* (*DumpNode
) (CHAR16
*);
2374 EFI_DEVICE_PATH_PROTOCOL
*DeviceNode
;
2376 EFI_DEVICE_PATH_PROTOCOL
*NewDevicePath
;
2377 CHAR16
*DevicePathStr
;
2379 CHAR16
*DeviceNodeStr
;
2380 UINT8 IsInstanceEnd
;
2381 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
2383 if ((TextDevicePath
== NULL
) || (IS_NULL (*TextDevicePath
))) {
2387 DevicePath
= (EFI_DEVICE_PATH_PROTOCOL
*) AllocatePool (END_DEVICE_PATH_LENGTH
);
2388 SetDevicePathEndNode (DevicePath
);
2391 DeviceNodeStr
= NULL
;
2392 DevicePathStr
= StrDuplicate (TextDevicePath
);
2394 Str
= DevicePathStr
;
2395 while ((DeviceNodeStr
= GetNextDeviceNodeStr (&Str
, &IsInstanceEnd
)) != NULL
) {
2397 for (Index
= 0; DevPathFromTextTable
[Index
].Function
; Index
++) {
2398 ParamStr
= GetParamByNodeName (DeviceNodeStr
, DevPathFromTextTable
[Index
].DevicePathNodeText
);
2399 if (ParamStr
!= NULL
) {
2400 DumpNode
= DevPathFromTextTable
[Index
].Function
;
2405 if (DumpNode
== NULL
) {
2409 DumpNode
= DevPathFromTextFilePath
;
2410 DeviceNode
= DumpNode (DeviceNodeStr
);
2412 DeviceNode
= DumpNode (ParamStr
);
2413 gBS
->FreePool (ParamStr
);
2416 NewDevicePath
= AppendDeviceNode (DevicePath
, DeviceNode
);
2417 gBS
->FreePool (DevicePath
);
2418 gBS
->FreePool (DeviceNode
);
2419 DevicePath
= NewDevicePath
;
2421 if (IsInstanceEnd
) {
2422 DeviceNode
= (EFI_DEVICE_PATH_PROTOCOL
*) AllocatePool (END_DEVICE_PATH_LENGTH
);
2423 SetDevicePathInstanceEndNode (DeviceNode
);
2425 NewDevicePath
= AppendDeviceNode (DevicePath
, DeviceNode
);
2426 gBS
->FreePool (DevicePath
);
2427 gBS
->FreePool (DeviceNode
);
2428 DevicePath
= NewDevicePath
;
2432 gBS
->FreePool (DevicePathStr
);