3 Copyright (c) 2006, Intel Corporation
4 All rights reserved. This program and the accompanying materials
5 are licensed and made available under the terms and conditions of the BSD License
6 which accompanies this distribution. The full text of the license may be found at
7 http://opensource.org/licenses/bsd-license.php
9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
18 DevicePathFromText protocol as defined in the UEFI 2.0 specification.
22 #include "DevicePath.h"
45 Length
= StrLen ((CHAR16
*) Src
);
47 ReturnStr
= AllocateCopyPool ((Length
+ 1) * sizeof (CHAR16
), (VOID
*) Src
);
61 Get parameter in a pair of parentheses follow the given node name.
62 For example, given the "Pci(0,1)" and NodeName "Pci", it returns "0,1".
65 Str - Device Path Text
66 NodeName - Name of the node
69 Parameter text for the node
76 UINTN ParameterLength
;
79 // Check whether the node name matchs
81 NodeNameLength
= StrLen (NodeName
);
82 if (CompareMem (Str
, NodeName
, NodeNameLength
* sizeof (CHAR16
)) != 0) {
86 ParamStr
= Str
+ NodeNameLength
;
87 if (!IS_LEFT_PARENTH (*ParamStr
)) {
92 // Skip the found '(' and find first occurrence of ')'
96 StrPointer
= ParamStr
;
97 while (!IS_NULL (*StrPointer
)) {
98 if (IS_RIGHT_PARENTH (*StrPointer
)) {
104 if (IS_NULL (*StrPointer
)) {
111 ParamStr
= AllocateCopyPool ((ParameterLength
+ 1) * sizeof (CHAR16
), ParamStr
);
112 if (ParamStr
== NULL
) {
116 // Terminate the parameter string
118 ParamStr
[ParameterLength
] = L
'\0';
126 IN OUT CHAR16
**List
,
132 Get current sub-string from a string list, before return
133 the list header is moved to next sub-string. The sub-string is separated
134 by the specified character. For example, the separator is ',', the string
135 list is "2,0,3", it returns "2", the remain list move to "2,3"
138 List - A string list separated by the specified separator
139 Separator - The separator character
142 pointer - The current sub-string
152 if (IS_NULL (*Str
)) {
157 // Find first occurrence of the separator
159 while (!IS_NULL (*Str
)) {
160 if (*Str
== Separator
) {
166 if (*Str
== Separator
) {
168 // Find a sub-string, terminate it
175 // Move to next sub-string
189 // The separator is comma
191 return SplitStr (List
, L
',');
196 GetNextDeviceNodeStr (
197 IN OUT CHAR16
**DevicePath
,
198 OUT BOOLEAN
*IsInstanceEnd
203 Get one device node from entire device path text.
206 Str - The entire device path text string
207 IsInstanceEnd - This node is the end of a device path instance
210 a pointer - A device node text
211 NULL - No more device node available
217 UINTN ParenthesesStack
;
220 if (IS_NULL (*Str
)) {
225 // Skip the leading '/', '(', ')' and ','
227 while (!IS_NULL (*Str
)) {
228 if (!IS_SLASH (*Str
) &&
230 !IS_LEFT_PARENTH (*Str
) &&
231 !IS_RIGHT_PARENTH (*Str
)) {
240 // Scan for the separator of this device node, '/' or ','
242 ParenthesesStack
= 0;
243 while (!IS_NULL (*Str
)) {
244 if ((IS_COMMA (*Str
) || IS_SLASH (*Str
)) && (ParenthesesStack
== 0)) {
248 if (IS_LEFT_PARENTH (*Str
)) {
250 } else if (IS_RIGHT_PARENTH (*Str
)) {
257 if (ParenthesesStack
!= 0) {
259 // The '(' doesn't pair with ')', invalid device path text
264 if (IS_COMMA (*Str
)) {
265 *IsInstanceEnd
= TRUE
;
269 *IsInstanceEnd
= FALSE
;
270 if (!IS_NULL (*Str
)) {
290 Determines if a Unicode character is a hexadecimal digit.
291 The test is case insensitive.
294 Digit - Pointer to byte that receives the value of the hex character.
295 Char - Unicode character to test.
298 TRUE - If the character is a hexadecimal digit.
303 if ((Char
>= L
'0') && (Char
<= L
'9')) {
304 *Digit
= (UINT8
) (Char
- L
'0');
308 if ((Char
>= L
'A') && (Char
<= L
'F')) {
309 *Digit
= (UINT8
) (Char
- L
'A' + 0x0A);
313 if ((Char
>= L
'a') && (Char
<= L
'f')) {
314 *Digit
= (UINT8
) (Char
- L
'a' + 0x0A);
327 OUT UINTN
*ConvertedStrLen OPTIONAL
332 Converts Unicode string to binary buffer.
333 The conversion may be partial.
334 The first character in the string that is not hex digit stops the conversion.
335 At a minimum, any blob of data could be represented as a hex string.
338 Buf - Pointer to buffer that receives the data.
339 Len - Length in bytes of the buffer to hold converted data.
340 If routine return with EFI_SUCCESS, containing length of converted data.
341 If routine return with EFI_BUFFER_TOO_SMALL, containg length of buffer desired.
342 Str - String to be converted from.
343 ConvertedStrLen - Length of the Hex String consumed.
346 EFI_SUCCESS: Routine Success.
347 EFI_BUFFER_TOO_SMALL: The buffer is too small to hold converted data.
359 // Find out how many hex characters the string has.
361 for (Idx
= 0, HexCnt
= 0; IsHexDigit (&Digit
, Str
[Idx
]); Idx
++, HexCnt
++);
368 // Two Unicode characters make up 1 buffer byte. Round up.
370 BufferLength
= (HexCnt
+ 1) / 2;
373 // Test if buffer is passed enough.
375 if (BufferLength
> (*Len
)) {
377 return EFI_BUFFER_TOO_SMALL
;
382 for (Idx
= 0; Idx
< HexCnt
; Idx
++) {
384 IsHexDigit (&Digit
, Str
[HexCnt
- 1 - Idx
]);
387 // For odd charaters, write the lower nibble for each buffer byte,
388 // and for even characters, the upper nibble.
390 if ((Idx
& 1) == 0) {
395 Byte
= (UINT8
) (Byte
| Digit
<< 4);
401 if (ConvertedStrLen
!= NULL
) {
402 *ConvertedStrLen
= HexCnt
;
416 Skip the leading white space and '0x' or '0X' of a hex string
426 // skip preceeding white space
428 while (*Str
&& *Str
== ' ') {
432 // skip preceeding zeros
434 while (*Str
&& *Str
== '0') {
438 // skip preceeding character 'x' or 'X'
440 if (*Str
&& (*Str
== 'x' || *Str
== 'X')) {
456 Convert hex string to uint
469 ASSERT (Str
!= NULL
);
472 // convert hex digits
475 Length
= sizeof (UINTN
);
476 HexStringToBuf ((UINT8
*) &Rvalue
, &Length
, TrimHexStr (Str
), NULL
);
491 Convert hex string to 64 bit data.
504 Length
= sizeof (UINT64
);
505 HexStringToBuf ((UINT8
*) Data
, &Length
, TrimHexStr (Str
), NULL
);
517 Convert decimal string to uint
532 ASSERT (str
!= NULL
);
534 High
= (UINTN
) -1 / 10;
535 Low
= (UINTN
) -1 % 10;
537 // skip preceeding white space
539 while (*str
&& *str
== ' ') {
548 if (Char
>= '0' && Char
<= '9') {
549 if ((Rvalue
> High
|| Rvalue
== High
) && (Char
- '0' > (INTN
) Low
)) {
553 Rvalue
= (Rvalue
* 10) + Char
- '0';
568 IN UINTN BufferLength
,
578 // Two hex char make up one byte
580 StrLength
= BufferLength
* sizeof (CHAR16
);
582 for(Index
= 0; Index
< StrLength
; Index
++, Str
++) {
584 IsHexDigit (&Digit
, *Str
);
587 // For odd charaters, write the upper nibble for each buffer byte,
588 // and for even characters, the lower nibble.
590 if ((Index
& 1) == 0) {
591 Byte
= (UINT8
) (Digit
<< 4);
593 Byte
= Buf
[Index
/ 2];
595 Byte
= (UINT8
) (Byte
| Digit
);
598 Buf
[Index
/ 2] = Byte
;
612 UINTN ConvertedStrLen
;
615 BufferLength
= sizeof (Guid
->Data1
);
616 Status
= HexStringToBuf ((UINT8
*) &Guid
->Data1
, &BufferLength
, Str
, &ConvertedStrLen
);
617 if (EFI_ERROR (Status
)) {
620 Str
+= ConvertedStrLen
;
621 if (IS_HYPHEN (*Str
)) {
624 return EFI_UNSUPPORTED
;
627 BufferLength
= sizeof (Guid
->Data2
);
628 Status
= HexStringToBuf ((UINT8
*) &Guid
->Data2
, &BufferLength
, Str
, &ConvertedStrLen
);
629 if (EFI_ERROR (Status
)) {
632 Str
+= ConvertedStrLen
;
633 if (IS_HYPHEN (*Str
)) {
636 return EFI_UNSUPPORTED
;
639 BufferLength
= sizeof (Guid
->Data3
);
640 Status
= HexStringToBuf ((UINT8
*) &Guid
->Data3
, &BufferLength
, Str
, &ConvertedStrLen
);
641 if (EFI_ERROR (Status
)) {
644 Str
+= ConvertedStrLen
;
645 if (IS_HYPHEN (*Str
)) {
648 return EFI_UNSUPPORTED
;
651 StrToBuf (&Guid
->Data4
[0], 2, Str
);
653 // Skip 2 byte hex chars
657 if (IS_HYPHEN (*Str
)) {
660 return EFI_UNSUPPORTED
;
662 StrToBuf (&Guid
->Data4
[2], 6, Str
);
671 OUT EFI_IPv4_ADDRESS
*IPv4Addr
676 for (Index
= 0; Index
< 4; Index
++) {
677 IPv4Addr
->Addr
[Index
] = (UINT8
) Atoi (SplitStr (Str
, L
'.'));
685 OUT EFI_IPv6_ADDRESS
*IPv6Addr
691 for (Index
= 0; Index
< 8; Index
++) {
692 Data
= (UINT16
) Xtoi (SplitStr (Str
, L
':'));
693 IPv6Addr
->Addr
[Index
* 2] = (UINT8
) (Data
>> 8);
694 IPv6Addr
->Addr
[Index
* 2 + 1] = (UINT8
) (Data
& 0xff);
702 IN OUT CHAR8
**AsciiStr
708 while (!IS_NULL (*Str
)) {
709 *(Dest
++) = (CHAR8
) *(Str
++);
714 // Return the string next to it
716 *AsciiStr
= Dest
+ 1;
720 EFI_DEVICE_PATH_PROTOCOL
*
722 IN CHAR16
*TextDeviceNode
727 PCI_DEVICE_PATH
*Pci
;
729 FunctionStr
= GetNextParamStr (&TextDeviceNode
);
730 DeviceStr
= GetNextParamStr (&TextDeviceNode
);
731 Pci
= (PCI_DEVICE_PATH
*) CreateDeviceNode (
732 HARDWARE_DEVICE_PATH
,
734 sizeof (PCI_DEVICE_PATH
)
737 Pci
->Function
= (UINT8
) Xtoi (FunctionStr
);
738 Pci
->Device
= (UINT8
) Xtoi (DeviceStr
);
740 return (EFI_DEVICE_PATH_PROTOCOL
*) Pci
;
744 EFI_DEVICE_PATH_PROTOCOL
*
745 DevPathFromTextPcCard (
746 IN CHAR16
*TextDeviceNode
749 CHAR16
*FunctionNumberStr
;
750 PCCARD_DEVICE_PATH
*Pccard
;
752 FunctionNumberStr
= GetNextParamStr (&TextDeviceNode
);
753 Pccard
= (PCCARD_DEVICE_PATH
*) CreateDeviceNode (
754 HARDWARE_DEVICE_PATH
,
756 sizeof (PCCARD_DEVICE_PATH
)
759 Pccard
->FunctionNumber
= (UINT8
) Xtoi (FunctionNumberStr
);
761 return (EFI_DEVICE_PATH_PROTOCOL
*) Pccard
;
765 EFI_DEVICE_PATH_PROTOCOL
*
766 DevPathFromTextMemoryMapped (
767 IN CHAR16
*TextDeviceNode
770 CHAR16
*StartingAddressStr
;
771 CHAR16
*EndingAddressStr
;
772 MEMMAP_DEVICE_PATH
*MemMap
;
774 StartingAddressStr
= GetNextParamStr (&TextDeviceNode
);
775 EndingAddressStr
= GetNextParamStr (&TextDeviceNode
);
776 MemMap
= (MEMMAP_DEVICE_PATH
*) CreateDeviceNode (
777 HARDWARE_DEVICE_PATH
,
779 sizeof (MEMMAP_DEVICE_PATH
)
782 MemMap
->MemoryType
= 0;
784 Xtoi64 (StartingAddressStr
, &MemMap
->StartingAddress
);
785 Xtoi64 (EndingAddressStr
, &MemMap
->EndingAddress
);
787 return (EFI_DEVICE_PATH_PROTOCOL
*) MemMap
;
791 EFI_DEVICE_PATH_PROTOCOL
*
792 ConvertFromTextVendor (
793 IN CHAR16
*TextDeviceNode
,
801 VENDOR_DEVICE_PATH
*Vendor
;
803 GuidStr
= GetNextParamStr (&TextDeviceNode
);
805 DataStr
= GetNextParamStr (&TextDeviceNode
);
806 Length
= StrLen (DataStr
);
808 // Two hex characters make up 1 buffer byte
810 Length
= (Length
+ 1) / 2;
812 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
815 sizeof (VENDOR_DEVICE_PATH
) + (UINT16
) Length
818 StrToGuid (GuidStr
, &Vendor
->Guid
);
819 StrToBuf (((UINT8
*) Vendor
) + sizeof (VENDOR_DEVICE_PATH
), Length
, DataStr
);
821 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
825 EFI_DEVICE_PATH_PROTOCOL
*
826 DevPathFromTextVenHw (
827 IN CHAR16
*TextDeviceNode
830 return ConvertFromTextVendor (
832 HARDWARE_DEVICE_PATH
,
838 EFI_DEVICE_PATH_PROTOCOL
*
839 DevPathFromTextCtrl (
840 IN CHAR16
*TextDeviceNode
843 CHAR16
*ControllerStr
;
844 CONTROLLER_DEVICE_PATH
*Controller
;
846 ControllerStr
= GetNextParamStr (&TextDeviceNode
);
847 Controller
= (CONTROLLER_DEVICE_PATH
*) CreateDeviceNode (
848 HARDWARE_DEVICE_PATH
,
850 sizeof (CONTROLLER_DEVICE_PATH
)
852 Controller
->ControllerNumber
= (UINT32
) Xtoi (ControllerStr
);
854 return (EFI_DEVICE_PATH_PROTOCOL
*) Controller
;
858 EFI_DEVICE_PATH_PROTOCOL
*
859 DevPathFromTextAcpi (
860 IN CHAR16
*TextDeviceNode
865 ACPI_HID_DEVICE_PATH
*Acpi
;
867 HIDStr
= GetNextParamStr (&TextDeviceNode
);
868 UIDStr
= GetNextParamStr (&TextDeviceNode
);
869 Acpi
= (ACPI_HID_DEVICE_PATH
*) CreateDeviceNode (
872 sizeof (ACPI_HID_DEVICE_PATH
)
875 if ((HIDStr
[0] == L
'P') && (HIDStr
[1] == L
'N') && (HIDStr
[2] == L
'P')) {
879 Acpi
->HID
= EISA_PNP_ID (Xtoi (HIDStr
));
880 Acpi
->UID
= (UINT32
) Xtoi (UIDStr
);
882 return (EFI_DEVICE_PATH_PROTOCOL
*) Acpi
;
886 EFI_DEVICE_PATH_PROTOCOL
*
887 ConvertFromTextAcpi (
888 IN CHAR16
*TextDeviceNode
,
893 ACPI_HID_DEVICE_PATH
*Acpi
;
895 UIDStr
= GetNextParamStr (&TextDeviceNode
);
896 Acpi
= (ACPI_HID_DEVICE_PATH
*) CreateDeviceNode (
899 sizeof (ACPI_HID_DEVICE_PATH
)
903 Acpi
->UID
= (UINT32
) Xtoi (UIDStr
);
905 return (EFI_DEVICE_PATH_PROTOCOL
*) Acpi
;
909 EFI_DEVICE_PATH_PROTOCOL
*
910 DevPathFromTextPciRoot (
911 IN CHAR16
*TextDeviceNode
914 return ConvertFromTextAcpi (TextDeviceNode
, 0x0a0341d0);
918 EFI_DEVICE_PATH_PROTOCOL
*
919 DevPathFromTextFloppy (
920 IN CHAR16
*TextDeviceNode
923 return ConvertFromTextAcpi (TextDeviceNode
, 0x060441d0);
927 EFI_DEVICE_PATH_PROTOCOL
*
928 DevPathFromTextKeyboard (
929 IN CHAR16
*TextDeviceNode
932 return ConvertFromTextAcpi (TextDeviceNode
, 0x030141d0);
936 EFI_DEVICE_PATH_PROTOCOL
*
937 DevPathFromTextSerial (
938 IN CHAR16
*TextDeviceNode
941 return ConvertFromTextAcpi (TextDeviceNode
, 0x050141d0);
945 EFI_DEVICE_PATH_PROTOCOL
*
946 DevPathFromTextParallelPort (
947 IN CHAR16
*TextDeviceNode
950 return ConvertFromTextAcpi (TextDeviceNode
, 0x040141d0);
954 EFI_DEVICE_PATH_PROTOCOL
*
955 DevPathFromTextAcpiEx (
956 IN CHAR16
*TextDeviceNode
967 ACPI_EXTENDED_HID_DEVICE_PATH_WITH_STR
*AcpiExt
;
969 HIDStr
= GetNextParamStr (&TextDeviceNode
);
970 CIDStr
= GetNextParamStr (&TextDeviceNode
);
971 UIDStr
= GetNextParamStr (&TextDeviceNode
);
972 HIDSTRStr
= GetNextParamStr (&TextDeviceNode
);
973 CIDSTRStr
= GetNextParamStr (&TextDeviceNode
);
974 UIDSTRStr
= GetNextParamStr (&TextDeviceNode
);
976 Length
= (UINT16
) (sizeof (ACPI_EXTENDED_HID_DEVICE_PATH
) + StrLen (HIDSTRStr
) + 1);
977 Length
= (UINT16
) (Length
+ StrLen (UIDSTRStr
) + 1);
978 Length
= (UINT16
) (Length
+ StrLen (CIDSTRStr
) + 1);
979 AcpiExt
= (ACPI_EXTENDED_HID_DEVICE_PATH_WITH_STR
*) CreateDeviceNode (
985 if ((HIDStr
[0] == L
'P') && (HIDStr
[1] == L
'N') && (HIDStr
[2] == L
'P')) {
987 AcpiExt
->HID
= EISA_PNP_ID (Xtoi (HIDStr
));
989 AcpiExt
->HID
= (UINT32
) Xtoi (HIDStr
);
992 AcpiExt
->UID
= (UINT32
) Xtoi (UIDStr
);
993 AcpiExt
->CID
= (UINT32
) Xtoi (CIDStr
);
995 AsciiStr
= AcpiExt
->HidUidCidStr
;
996 StrToAscii (HIDSTRStr
, &AsciiStr
);
997 StrToAscii (UIDSTRStr
, &AsciiStr
);
998 StrToAscii (CIDSTRStr
, &AsciiStr
);
1000 return (EFI_DEVICE_PATH_PROTOCOL
*) AcpiExt
;
1004 EFI_DEVICE_PATH_PROTOCOL
*
1005 DevPathFromTextAcpiExp (
1006 IN CHAR16
*TextDeviceNode
1014 ACPI_EXTENDED_HID_DEVICE_PATH_WITH_STR
*AcpiExt
;
1016 HIDStr
= GetNextParamStr (&TextDeviceNode
);
1017 CIDStr
= GetNextParamStr (&TextDeviceNode
);
1018 UIDSTRStr
= GetNextParamStr (&TextDeviceNode
);
1019 Length
= sizeof (ACPI_EXTENDED_HID_DEVICE_PATH
) + (UINT16
) StrLen (UIDSTRStr
) + 3;
1020 AcpiExt
= (ACPI_EXTENDED_HID_DEVICE_PATH_WITH_STR
*) CreateDeviceNode (
1026 if ((HIDStr
[0] == L
'P') && (HIDStr
[1] == L
'N') && (HIDStr
[2] == L
'P')) {
1028 AcpiExt
->HID
= EISA_PNP_ID (Xtoi (HIDStr
));
1030 AcpiExt
->HID
= (UINT32
) Xtoi (HIDStr
);
1034 AcpiExt
->CID
= (UINT32
) Xtoi (CIDStr
);
1036 AsciiStr
= AcpiExt
->HidUidCidStr
;
1038 // HID string is NULL
1042 // Convert UID string
1045 StrToAscii (UIDSTRStr
, &AsciiStr
);
1047 // CID string is NULL
1051 return (EFI_DEVICE_PATH_PROTOCOL
*) AcpiExt
;
1055 EFI_DEVICE_PATH_PROTOCOL
*
1056 DevPathFromTextAta (
1057 IN CHAR16
*TextDeviceNode
1060 CHAR16
*PrimarySecondaryStr
;
1061 CHAR16
*SlaveMasterStr
;
1063 ATAPI_DEVICE_PATH
*Atapi
;
1065 Atapi
= (ATAPI_DEVICE_PATH
*) CreateDeviceNode (
1066 MESSAGING_DEVICE_PATH
,
1068 sizeof (ATAPI_DEVICE_PATH
)
1071 PrimarySecondaryStr
= GetNextParamStr (&TextDeviceNode
);
1072 SlaveMasterStr
= GetNextParamStr (&TextDeviceNode
);
1073 LunStr
= GetNextParamStr (&TextDeviceNode
);
1075 Atapi
->PrimarySecondary
= (UINT8
) ((StrCmp (PrimarySecondaryStr
, L
"Primary") == 0) ? 0 : 1);
1076 Atapi
->SlaveMaster
= (UINT8
) ((StrCmp (SlaveMasterStr
, L
"Master") == 0) ? 0 : 1);
1077 Atapi
->Lun
= (UINT16
) Xtoi (LunStr
);
1079 return (EFI_DEVICE_PATH_PROTOCOL
*) Atapi
;
1083 EFI_DEVICE_PATH_PROTOCOL
*
1084 DevPathFromTextScsi (
1085 IN CHAR16
*TextDeviceNode
1090 SCSI_DEVICE_PATH
*Scsi
;
1092 PunStr
= GetNextParamStr (&TextDeviceNode
);
1093 LunStr
= GetNextParamStr (&TextDeviceNode
);
1094 Scsi
= (SCSI_DEVICE_PATH
*) CreateDeviceNode (
1095 MESSAGING_DEVICE_PATH
,
1097 sizeof (SCSI_DEVICE_PATH
)
1100 Scsi
->Pun
= (UINT16
) Xtoi (PunStr
);
1101 Scsi
->Lun
= (UINT16
) Xtoi (LunStr
);
1103 return (EFI_DEVICE_PATH_PROTOCOL
*) Scsi
;
1107 EFI_DEVICE_PATH_PROTOCOL
*
1108 DevPathFromTextFibre (
1109 IN CHAR16
*TextDeviceNode
1114 FIBRECHANNEL_DEVICE_PATH
*Fibre
;
1116 WWNStr
= GetNextParamStr (&TextDeviceNode
);
1117 LunStr
= GetNextParamStr (&TextDeviceNode
);
1118 Fibre
= (FIBRECHANNEL_DEVICE_PATH
*) CreateDeviceNode (
1119 MESSAGING_DEVICE_PATH
,
1120 MSG_FIBRECHANNEL_DP
,
1121 sizeof (FIBRECHANNEL_DEVICE_PATH
)
1124 Fibre
->Reserved
= 0;
1125 Xtoi64 (WWNStr
, &Fibre
->WWN
);
1126 Xtoi64 (LunStr
, &Fibre
->Lun
);
1128 return (EFI_DEVICE_PATH_PROTOCOL
*) Fibre
;
1132 EFI_DEVICE_PATH_PROTOCOL
*
1133 DevPathFromText1394 (
1134 IN CHAR16
*TextDeviceNode
1138 F1394_DEVICE_PATH
*F1394
;
1140 GuidStr
= GetNextParamStr (&TextDeviceNode
);
1141 F1394
= (F1394_DEVICE_PATH
*) CreateDeviceNode (
1142 MESSAGING_DEVICE_PATH
,
1144 sizeof (F1394_DEVICE_PATH
)
1147 F1394
->Reserved
= 0;
1148 Xtoi64 (GuidStr
, &F1394
->Guid
);
1150 return (EFI_DEVICE_PATH_PROTOCOL
*) F1394
;
1154 EFI_DEVICE_PATH_PROTOCOL
*
1155 DevPathFromTextUsb (
1156 IN CHAR16
*TextDeviceNode
1160 CHAR16
*InterfaceStr
;
1161 USB_DEVICE_PATH
*Usb
;
1163 PortStr
= GetNextParamStr (&TextDeviceNode
);
1164 InterfaceStr
= GetNextParamStr (&TextDeviceNode
);
1165 Usb
= (USB_DEVICE_PATH
*) CreateDeviceNode (
1166 MESSAGING_DEVICE_PATH
,
1168 sizeof (USB_DEVICE_PATH
)
1171 Usb
->ParentPortNumber
= (UINT8
) Xtoi (PortStr
);
1172 Usb
->InterfaceNumber
= (UINT8
) Xtoi (InterfaceStr
);
1174 return (EFI_DEVICE_PATH_PROTOCOL
*) Usb
;
1178 EFI_DEVICE_PATH_PROTOCOL
*
1179 DevPathFromTextI2O (
1180 IN CHAR16
*TextDeviceNode
1184 I2O_DEVICE_PATH
*I2O
;
1186 TIDStr
= GetNextParamStr (&TextDeviceNode
);
1187 I2O
= (I2O_DEVICE_PATH
*) CreateDeviceNode (
1188 MESSAGING_DEVICE_PATH
,
1190 sizeof (I2O_DEVICE_PATH
)
1193 I2O
->Tid
= (UINT32
) Xtoi (TIDStr
);
1195 return (EFI_DEVICE_PATH_PROTOCOL
*) I2O
;
1199 EFI_DEVICE_PATH_PROTOCOL
*
1200 DevPathFromTextInfiniband (
1201 IN CHAR16
*TextDeviceNode
1210 INFINIBAND_DEVICE_PATH
*InfiniBand
;
1212 FlagsStr
= GetNextParamStr (&TextDeviceNode
);
1213 GuidStr
= GetNextParamStr (&TextDeviceNode
);
1214 SidStr
= GetNextParamStr (&TextDeviceNode
);
1215 TidStr
= GetNextParamStr (&TextDeviceNode
);
1216 DidStr
= GetNextParamStr (&TextDeviceNode
);
1217 InfiniBand
= (INFINIBAND_DEVICE_PATH
*) CreateDeviceNode (
1218 MESSAGING_DEVICE_PATH
,
1220 sizeof (INFINIBAND_DEVICE_PATH
)
1223 InfiniBand
->ResourceFlags
= (UINT32
) Xtoi (FlagsStr
);
1224 StrToGuid (GuidStr
, &PortGid
);
1225 CopyMem (InfiniBand
->PortGid
, &PortGid
, sizeof (EFI_GUID
));
1226 Xtoi64 (SidStr
, &InfiniBand
->ServiceId
);
1227 Xtoi64 (TidStr
, &InfiniBand
->TargetPortId
);
1228 Xtoi64 (DidStr
, &InfiniBand
->DeviceId
);
1230 return (EFI_DEVICE_PATH_PROTOCOL
*) InfiniBand
;
1234 EFI_DEVICE_PATH_PROTOCOL
*
1235 DevPathFromTextVenMsg (
1236 IN CHAR16
*TextDeviceNode
1239 return ConvertFromTextVendor (
1241 MESSAGING_DEVICE_PATH
,
1247 EFI_DEVICE_PATH_PROTOCOL
*
1248 DevPathFromTextVenPcAnsi (
1249 IN CHAR16
*TextDeviceNode
1252 VENDOR_DEVICE_PATH
*Vendor
;
1254 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
1255 MESSAGING_DEVICE_PATH
,
1257 sizeof (VENDOR_DEVICE_PATH
));
1258 CopyGuid (&Vendor
->Guid
, &gEfiPcAnsiGuid
);
1260 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
1264 EFI_DEVICE_PATH_PROTOCOL
*
1265 DevPathFromTextVenVt100 (
1266 IN CHAR16
*TextDeviceNode
1269 VENDOR_DEVICE_PATH
*Vendor
;
1271 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
1272 MESSAGING_DEVICE_PATH
,
1274 sizeof (VENDOR_DEVICE_PATH
));
1275 CopyGuid (&Vendor
->Guid
, &gEfiVT100Guid
);
1277 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
1281 EFI_DEVICE_PATH_PROTOCOL
*
1282 DevPathFromTextVenVt100Plus (
1283 IN CHAR16
*TextDeviceNode
1286 VENDOR_DEVICE_PATH
*Vendor
;
1288 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
1289 MESSAGING_DEVICE_PATH
,
1291 sizeof (VENDOR_DEVICE_PATH
));
1292 CopyGuid (&Vendor
->Guid
, &gEfiVT100PlusGuid
);
1294 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
1298 EFI_DEVICE_PATH_PROTOCOL
*
1299 DevPathFromTextVenUtf8 (
1300 IN CHAR16
*TextDeviceNode
1303 VENDOR_DEVICE_PATH
*Vendor
;
1305 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
1306 MESSAGING_DEVICE_PATH
,
1308 sizeof (VENDOR_DEVICE_PATH
));
1309 CopyGuid (&Vendor
->Guid
, &gEfiVTUTF8Guid
);
1311 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
1315 EFI_DEVICE_PATH_PROTOCOL
*
1316 DevPathFromTextUartFlowCtrl (
1317 IN CHAR16
*TextDeviceNode
1321 UART_FLOW_CONTROL_DEVICE_PATH
*UartFlowControl
;
1323 ValueStr
= GetNextParamStr (&TextDeviceNode
);
1324 UartFlowControl
= (UART_FLOW_CONTROL_DEVICE_PATH
*) CreateDeviceNode (
1325 MESSAGING_DEVICE_PATH
,
1327 sizeof (UART_FLOW_CONTROL_DEVICE_PATH
)
1330 CopyGuid (&UartFlowControl
->Guid
, &mEfiDevicePathMessagingUartFlowControlGuid
);
1331 if (StrCmp (ValueStr
, L
"XonXoff") == 0) {
1332 UartFlowControl
->FlowControlMap
= 2;
1333 } else if (StrCmp (ValueStr
, L
"Hardware") == 0) {
1334 UartFlowControl
->FlowControlMap
= 1;
1336 UartFlowControl
->FlowControlMap
= 0;
1339 return (EFI_DEVICE_PATH_PROTOCOL
*) UartFlowControl
;
1343 EFI_DEVICE_PATH_PROTOCOL
*
1344 DevPathFromTextSAS (
1345 IN CHAR16
*TextDeviceNode
1352 CHAR16
*LocationStr
;
1354 CHAR16
*DriveBayStr
;
1355 CHAR16
*ReservedStr
;
1357 SAS_DEVICE_PATH
*Sas
;
1359 AddressStr
= GetNextParamStr (&TextDeviceNode
);
1360 LunStr
= GetNextParamStr (&TextDeviceNode
);
1361 RTPStr
= GetNextParamStr (&TextDeviceNode
);
1362 SASSATAStr
= GetNextParamStr (&TextDeviceNode
);
1363 LocationStr
= GetNextParamStr (&TextDeviceNode
);
1364 ConnectStr
= GetNextParamStr (&TextDeviceNode
);
1365 DriveBayStr
= GetNextParamStr (&TextDeviceNode
);
1366 ReservedStr
= GetNextParamStr (&TextDeviceNode
);
1368 Sas
= (SAS_DEVICE_PATH
*) CreateDeviceNode (
1369 MESSAGING_DEVICE_PATH
,
1371 sizeof (SAS_DEVICE_PATH
)
1374 CopyGuid (&Sas
->Guid
, &mEfiDevicePathMessagingSASGuid
);
1375 Xtoi64 (AddressStr
, &Sas
->SasAddress
);
1376 Xtoi64 (LunStr
, &Sas
->Lun
);
1377 Sas
->RelativeTargetPort
= (UINT16
) Xtoi (RTPStr
);
1378 if (StrCmp (SASSATAStr
, L
"NoTopology") == 0)
1381 if (StrCmp (DriveBayStr
, L
"0") == 0) {
1385 Info
|= (Xtoi (DriveBayStr
) << 8);
1388 if (StrCmp (SASSATAStr
, L
"SATA") == 0) {
1392 if (StrCmp (LocationStr
, L
"External") == 0) {
1396 if (StrCmp (ConnectStr
, L
"Expanded") == 0) {
1401 Sas
->DeviceTopology
= Info
;
1402 Sas
->Reserved
= (UINT32
) Xtoi (ReservedStr
);
1404 return (EFI_DEVICE_PATH_PROTOCOL
*) Sas
;
1408 EFI_DEVICE_PATH_PROTOCOL
*
1409 DevPathFromTextDebugPort (
1410 IN CHAR16
*TextDeviceNode
1413 VENDOR_DEFINED_MESSAGING_DEVICE_PATH
*Vend
;
1415 Vend
= (VENDOR_DEFINED_MESSAGING_DEVICE_PATH
*) CreateDeviceNode (
1416 MESSAGING_DEVICE_PATH
,
1418 sizeof (VENDOR_DEFINED_MESSAGING_DEVICE_PATH
)
1421 CopyGuid (&Vend
->Guid
, &gEfiDebugPortProtocolGuid
);
1423 return (EFI_DEVICE_PATH_PROTOCOL
*) Vend
;
1427 EFI_DEVICE_PATH_PROTOCOL
*
1428 DevPathFromTextMAC (
1429 IN CHAR16
*TextDeviceNode
1435 MAC_ADDR_DEVICE_PATH
*MAC
;
1437 AddressStr
= GetNextParamStr (&TextDeviceNode
);
1438 IfTypeStr
= GetNextParamStr (&TextDeviceNode
);
1439 MAC
= (MAC_ADDR_DEVICE_PATH
*) CreateDeviceNode (
1440 MESSAGING_DEVICE_PATH
,
1442 sizeof (MAC_ADDR_DEVICE_PATH
)
1445 MAC
->IfType
= (UINT8
) Xtoi (IfTypeStr
);
1447 Length
= sizeof (EFI_MAC_ADDRESS
);
1448 StrToBuf (&MAC
->MacAddress
.Addr
[0], Length
, AddressStr
);
1450 return (EFI_DEVICE_PATH_PROTOCOL
*) MAC
;
1454 EFI_DEVICE_PATH_PROTOCOL
*
1455 DevPathFromTextIPv4 (
1456 IN CHAR16
*TextDeviceNode
1459 CHAR16
*RemoteIPStr
;
1460 CHAR16
*ProtocolStr
;
1463 IPv4_DEVICE_PATH
*IPv4
;
1465 RemoteIPStr
= GetNextParamStr (&TextDeviceNode
);
1466 ProtocolStr
= GetNextParamStr (&TextDeviceNode
);
1467 TypeStr
= GetNextParamStr (&TextDeviceNode
);
1468 LocalIPStr
= GetNextParamStr (&TextDeviceNode
);
1469 IPv4
= (IPv4_DEVICE_PATH
*) CreateDeviceNode (
1470 MESSAGING_DEVICE_PATH
,
1472 sizeof (IPv4_DEVICE_PATH
)
1475 StrToIPv4Addr (&RemoteIPStr
, &IPv4
->RemoteIpAddress
);
1476 IPv4
->Protocol
= (UINT16
) ((StrCmp (ProtocolStr
, L
"UDP") == 0) ? 0 : 1);
1477 if (StrCmp (TypeStr
, L
"Static") == 0) {
1478 IPv4
->StaticIpAddress
= TRUE
;
1480 IPv4
->StaticIpAddress
= FALSE
;
1483 StrToIPv4Addr (&LocalIPStr
, &IPv4
->LocalIpAddress
);
1485 IPv4
->LocalPort
= 0;
1486 IPv4
->RemotePort
= 0;
1488 return (EFI_DEVICE_PATH_PROTOCOL
*) IPv4
;
1492 EFI_DEVICE_PATH_PROTOCOL
*
1493 DevPathFromTextIPv6 (
1494 IN CHAR16
*TextDeviceNode
1497 CHAR16
*RemoteIPStr
;
1498 CHAR16
*ProtocolStr
;
1501 IPv6_DEVICE_PATH
*IPv6
;
1503 RemoteIPStr
= GetNextParamStr (&TextDeviceNode
);
1504 ProtocolStr
= GetNextParamStr (&TextDeviceNode
);
1505 TypeStr
= GetNextParamStr (&TextDeviceNode
);
1506 LocalIPStr
= GetNextParamStr (&TextDeviceNode
);
1507 IPv6
= (IPv6_DEVICE_PATH
*) CreateDeviceNode (
1508 MESSAGING_DEVICE_PATH
,
1510 sizeof (IPv6_DEVICE_PATH
)
1513 StrToIPv6Addr (&RemoteIPStr
, &IPv6
->RemoteIpAddress
);
1514 IPv6
->Protocol
= (UINT16
) ((StrCmp (ProtocolStr
, L
"UDP") == 0) ? 0 : 1);
1515 if (StrCmp (TypeStr
, L
"Static") == 0) {
1516 IPv6
->StaticIpAddress
= TRUE
;
1518 IPv6
->StaticIpAddress
= FALSE
;
1521 StrToIPv6Addr (&LocalIPStr
, &IPv6
->LocalIpAddress
);
1523 IPv6
->LocalPort
= 0;
1524 IPv6
->RemotePort
= 0;
1526 return (EFI_DEVICE_PATH_PROTOCOL
*) IPv6
;
1530 EFI_DEVICE_PATH_PROTOCOL
*
1531 DevPathFromTextUart (
1532 IN CHAR16
*TextDeviceNode
1536 CHAR16
*DataBitsStr
;
1538 CHAR16
*StopBitsStr
;
1539 UART_DEVICE_PATH
*Uart
;
1541 BaudStr
= GetNextParamStr (&TextDeviceNode
);
1542 DataBitsStr
= GetNextParamStr (&TextDeviceNode
);
1543 ParityStr
= GetNextParamStr (&TextDeviceNode
);
1544 StopBitsStr
= GetNextParamStr (&TextDeviceNode
);
1545 Uart
= (UART_DEVICE_PATH
*) CreateDeviceNode (
1546 MESSAGING_DEVICE_PATH
,
1548 sizeof (UART_DEVICE_PATH
)
1551 Uart
->BaudRate
= (StrCmp (BaudStr
, L
"DEFAULT") == 0) ? 115200 : Atoi (BaudStr
);
1552 Uart
->DataBits
= (UINT8
) ((StrCmp (DataBitsStr
, L
"DEFAULT") == 0) ? 8 : Atoi (DataBitsStr
));
1553 switch (*ParityStr
) {
1578 Uart
->Parity
= 0xff;
1581 if (StrCmp (StopBitsStr
, L
"D") == 0) {
1582 Uart
->StopBits
= (UINT8
) 0;
1583 } else if (StrCmp (StopBitsStr
, L
"1") == 0) {
1584 Uart
->StopBits
= (UINT8
) 1;
1585 } else if (StrCmp (StopBitsStr
, L
"1.5") == 0) {
1586 Uart
->StopBits
= (UINT8
) 2;
1587 } else if (StrCmp (StopBitsStr
, L
"2") == 0) {
1588 Uart
->StopBits
= (UINT8
) 3;
1590 Uart
->StopBits
= 0xff;
1593 return (EFI_DEVICE_PATH_PROTOCOL
*) Uart
;
1597 EFI_DEVICE_PATH_PROTOCOL
*
1598 ConvertFromTextUsbClass (
1599 IN CHAR16
*TextDeviceNode
,
1600 IN USB_CLASS_TEXT
*UsbClassText
1606 CHAR16
*SubClassStr
;
1607 CHAR16
*ProtocolStr
;
1608 USB_CLASS_DEVICE_PATH
*UsbClass
;
1610 UsbClass
= (USB_CLASS_DEVICE_PATH
*) CreateDeviceNode (
1611 MESSAGING_DEVICE_PATH
,
1613 sizeof (USB_CLASS_DEVICE_PATH
)
1616 VIDStr
= GetNextParamStr (&TextDeviceNode
);
1617 PIDStr
= GetNextParamStr (&TextDeviceNode
);
1618 if (UsbClassText
->ClassExist
) {
1619 ClassStr
= GetNextParamStr (&TextDeviceNode
);
1620 UsbClass
->DeviceClass
= (UINT8
) Xtoi (ClassStr
);
1622 UsbClass
->DeviceClass
= UsbClassText
->Class
;
1624 if (UsbClassText
->SubClassExist
) {
1625 SubClassStr
= GetNextParamStr (&TextDeviceNode
);
1626 UsbClass
->DeviceSubClass
= (UINT8
) Xtoi (SubClassStr
);
1628 UsbClass
->DeviceSubClass
= UsbClassText
->SubClass
;
1631 ProtocolStr
= GetNextParamStr (&TextDeviceNode
);
1633 UsbClass
->VendorId
= (UINT16
) Xtoi (VIDStr
);
1634 UsbClass
->ProductId
= (UINT16
) Xtoi (PIDStr
);
1635 UsbClass
->DeviceProtocol
= (UINT8
) Xtoi (ProtocolStr
);
1637 return (EFI_DEVICE_PATH_PROTOCOL
*) UsbClass
;
1642 EFI_DEVICE_PATH_PROTOCOL
*
1643 DevPathFromTextUsbClass (
1644 IN CHAR16
*TextDeviceNode
1647 USB_CLASS_TEXT UsbClassText
;
1649 UsbClassText
.ClassExist
= TRUE
;
1650 UsbClassText
.SubClassExist
= TRUE
;
1652 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1656 EFI_DEVICE_PATH_PROTOCOL
*
1657 DevPathFromTextUsbAudio (
1658 IN CHAR16
*TextDeviceNode
1661 USB_CLASS_TEXT UsbClassText
;
1663 UsbClassText
.ClassExist
= FALSE
;
1664 UsbClassText
.Class
= USB_CLASS_AUDIO
;
1665 UsbClassText
.SubClassExist
= TRUE
;
1667 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1671 EFI_DEVICE_PATH_PROTOCOL
*
1672 DevPathFromTextUsbCDCControl (
1673 IN CHAR16
*TextDeviceNode
1676 USB_CLASS_TEXT UsbClassText
;
1678 UsbClassText
.ClassExist
= FALSE
;
1679 UsbClassText
.Class
= USB_CLASS_CDCCONTROL
;
1680 UsbClassText
.SubClassExist
= TRUE
;
1682 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1686 EFI_DEVICE_PATH_PROTOCOL
*
1687 DevPathFromTextUsbHID (
1688 IN CHAR16
*TextDeviceNode
1691 USB_CLASS_TEXT UsbClassText
;
1693 UsbClassText
.ClassExist
= FALSE
;
1694 UsbClassText
.Class
= USB_CLASS_HID
;
1695 UsbClassText
.SubClassExist
= TRUE
;
1697 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1701 EFI_DEVICE_PATH_PROTOCOL
*
1702 DevPathFromTextUsbImage (
1703 IN CHAR16
*TextDeviceNode
1706 USB_CLASS_TEXT UsbClassText
;
1708 UsbClassText
.ClassExist
= FALSE
;
1709 UsbClassText
.Class
= USB_CLASS_IMAGE
;
1710 UsbClassText
.SubClassExist
= TRUE
;
1712 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1716 EFI_DEVICE_PATH_PROTOCOL
*
1717 DevPathFromTextUsbPrinter (
1718 IN CHAR16
*TextDeviceNode
1721 USB_CLASS_TEXT UsbClassText
;
1723 UsbClassText
.ClassExist
= FALSE
;
1724 UsbClassText
.Class
= USB_CLASS_PRINTER
;
1725 UsbClassText
.SubClassExist
= TRUE
;
1727 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1731 EFI_DEVICE_PATH_PROTOCOL
*
1732 DevPathFromTextUsbMassStorage (
1733 IN CHAR16
*TextDeviceNode
1736 USB_CLASS_TEXT UsbClassText
;
1738 UsbClassText
.ClassExist
= FALSE
;
1739 UsbClassText
.Class
= USB_CLASS_MASS_STORAGE
;
1740 UsbClassText
.SubClassExist
= TRUE
;
1742 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1746 EFI_DEVICE_PATH_PROTOCOL
*
1747 DevPathFromTextUsbHub (
1748 IN CHAR16
*TextDeviceNode
1751 USB_CLASS_TEXT UsbClassText
;
1753 UsbClassText
.ClassExist
= FALSE
;
1754 UsbClassText
.Class
= USB_CLASS_HUB
;
1755 UsbClassText
.SubClassExist
= TRUE
;
1757 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1761 EFI_DEVICE_PATH_PROTOCOL
*
1762 DevPathFromTextUsbCDCData (
1763 IN CHAR16
*TextDeviceNode
1766 USB_CLASS_TEXT UsbClassText
;
1768 UsbClassText
.ClassExist
= FALSE
;
1769 UsbClassText
.Class
= USB_CLASS_CDCDATA
;
1770 UsbClassText
.SubClassExist
= TRUE
;
1772 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1776 EFI_DEVICE_PATH_PROTOCOL
*
1777 DevPathFromTextUsbSmartCard (
1778 IN CHAR16
*TextDeviceNode
1781 USB_CLASS_TEXT UsbClassText
;
1783 UsbClassText
.ClassExist
= FALSE
;
1784 UsbClassText
.Class
= USB_CLASS_SMART_CARD
;
1785 UsbClassText
.SubClassExist
= TRUE
;
1787 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1791 EFI_DEVICE_PATH_PROTOCOL
*
1792 DevPathFromTextUsbVideo (
1793 IN CHAR16
*TextDeviceNode
1796 USB_CLASS_TEXT UsbClassText
;
1798 UsbClassText
.ClassExist
= FALSE
;
1799 UsbClassText
.Class
= USB_CLASS_VIDEO
;
1800 UsbClassText
.SubClassExist
= TRUE
;
1802 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1806 EFI_DEVICE_PATH_PROTOCOL
*
1807 DevPathFromTextUsbDiagnostic (
1808 IN CHAR16
*TextDeviceNode
1811 USB_CLASS_TEXT UsbClassText
;
1813 UsbClassText
.ClassExist
= FALSE
;
1814 UsbClassText
.Class
= USB_CLASS_DIAGNOSTIC
;
1815 UsbClassText
.SubClassExist
= TRUE
;
1817 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1821 EFI_DEVICE_PATH_PROTOCOL
*
1822 DevPathFromTextUsbWireless (
1823 IN CHAR16
*TextDeviceNode
1826 USB_CLASS_TEXT UsbClassText
;
1828 UsbClassText
.ClassExist
= FALSE
;
1829 UsbClassText
.Class
= USB_CLASS_WIRELESS
;
1830 UsbClassText
.SubClassExist
= TRUE
;
1832 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1836 EFI_DEVICE_PATH_PROTOCOL
*
1837 DevPathFromTextUsbDeviceFirmwareUpdate (
1838 IN CHAR16
*TextDeviceNode
1841 USB_CLASS_TEXT UsbClassText
;
1843 UsbClassText
.ClassExist
= FALSE
;
1844 UsbClassText
.Class
= USB_CLASS_RESERVE
;
1845 UsbClassText
.SubClassExist
= FALSE
;
1846 UsbClassText
.SubClass
= USB_SUBCLASS_FW_UPDATE
;
1848 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1852 EFI_DEVICE_PATH_PROTOCOL
*
1853 DevPathFromTextUsbIrdaBridge (
1854 IN CHAR16
*TextDeviceNode
1857 USB_CLASS_TEXT UsbClassText
;
1859 UsbClassText
.ClassExist
= FALSE
;
1860 UsbClassText
.Class
= USB_CLASS_RESERVE
;
1861 UsbClassText
.SubClassExist
= FALSE
;
1862 UsbClassText
.SubClass
= USB_SUBCLASS_IRDA_BRIDGE
;
1864 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1868 EFI_DEVICE_PATH_PROTOCOL
*
1869 DevPathFromTextUsbTestAndMeasurement (
1870 IN CHAR16
*TextDeviceNode
1873 USB_CLASS_TEXT UsbClassText
;
1875 UsbClassText
.ClassExist
= FALSE
;
1876 UsbClassText
.Class
= USB_CLASS_RESERVE
;
1877 UsbClassText
.SubClassExist
= FALSE
;
1878 UsbClassText
.SubClass
= USB_SUBCLASS_TEST
;
1880 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1884 EFI_DEVICE_PATH_PROTOCOL
*
1885 DevPathFromTextUsbWwid (
1886 IN CHAR16
*TextDeviceNode
1891 CHAR16
*InterfaceNumStr
;
1892 USB_WWID_DEVICE_PATH
*UsbWwid
;
1894 VIDStr
= GetNextParamStr (&TextDeviceNode
);
1895 PIDStr
= GetNextParamStr (&TextDeviceNode
);
1896 InterfaceNumStr
= GetNextParamStr (&TextDeviceNode
);
1897 UsbWwid
= (USB_WWID_DEVICE_PATH
*) CreateDeviceNode (
1898 MESSAGING_DEVICE_PATH
,
1900 sizeof (USB_WWID_DEVICE_PATH
)
1903 UsbWwid
->VendorId
= (UINT16
) Xtoi (VIDStr
);
1904 UsbWwid
->ProductId
= (UINT16
) Xtoi (PIDStr
);
1905 UsbWwid
->InterfaceNumber
= (UINT16
) Xtoi (InterfaceNumStr
);
1907 return (EFI_DEVICE_PATH_PROTOCOL
*) UsbWwid
;
1911 EFI_DEVICE_PATH_PROTOCOL
*
1912 DevPathFromTextUnit (
1913 IN CHAR16
*TextDeviceNode
1917 DEVICE_LOGICAL_UNIT_DEVICE_PATH
*LogicalUnit
;
1919 LunStr
= GetNextParamStr (&TextDeviceNode
);
1920 LogicalUnit
= (DEVICE_LOGICAL_UNIT_DEVICE_PATH
*) CreateDeviceNode (
1921 MESSAGING_DEVICE_PATH
,
1922 MSG_DEVICE_LOGICAL_UNIT_DP
,
1923 sizeof (DEVICE_LOGICAL_UNIT_DEVICE_PATH
)
1926 LogicalUnit
->Lun
= (UINT8
) Xtoi (LunStr
);
1928 return (EFI_DEVICE_PATH_PROTOCOL
*) LogicalUnit
;
1932 EFI_DEVICE_PATH_PROTOCOL
*
1933 DevPathFromTextiSCSI (
1934 IN CHAR16
*TextDeviceNode
1939 CHAR16
*PortalGroupStr
;
1941 CHAR16
*HeaderDigestStr
;
1942 CHAR16
*DataDigestStr
;
1943 CHAR16
*AuthenticationStr
;
1944 CHAR16
*ProtocolStr
;
1945 ISCSI_DEVICE_PATH_WITH_NAME
*iSCSI
;
1947 NameStr
= GetNextParamStr (&TextDeviceNode
);
1948 PortalGroupStr
= GetNextParamStr (&TextDeviceNode
);
1949 LunStr
= GetNextParamStr (&TextDeviceNode
);
1950 HeaderDigestStr
= GetNextParamStr (&TextDeviceNode
);
1951 DataDigestStr
= GetNextParamStr (&TextDeviceNode
);
1952 AuthenticationStr
= GetNextParamStr (&TextDeviceNode
);
1953 ProtocolStr
= GetNextParamStr (&TextDeviceNode
);
1954 iSCSI
= (ISCSI_DEVICE_PATH_WITH_NAME
*) CreateDeviceNode (
1955 MESSAGING_DEVICE_PATH
,
1957 sizeof (ISCSI_DEVICE_PATH_WITH_NAME
) + (UINT16
) (StrLen (NameStr
) * 2)
1960 StrCpy (iSCSI
->iSCSITargetName
, NameStr
);
1961 iSCSI
->TargetPortalGroupTag
= (UINT16
) Xtoi (PortalGroupStr
);
1962 Xtoi64 (LunStr
, &iSCSI
->Lun
);
1965 if (StrCmp (HeaderDigestStr
, L
"CRC32C") == 0) {
1969 if (StrCmp (DataDigestStr
, L
"CRC32C") == 0) {
1973 if (StrCmp (AuthenticationStr
, L
"None") == 0) {
1977 if (StrCmp (AuthenticationStr
, L
"CHAP_UNI") == 0) {
1981 iSCSI
->LoginOption
= (UINT16
) Options
;
1983 iSCSI
->NetworkProtocol
= (UINT16
) StrCmp (ProtocolStr
, L
"TCP");
1984 iSCSI
->Reserved
= (UINT16
) 0;
1986 return (EFI_DEVICE_PATH_PROTOCOL
*) iSCSI
;
1990 EFI_DEVICE_PATH_PROTOCOL
*
1992 IN CHAR16
*TextDeviceNode
1995 CHAR16
*PartitionStr
;
1997 CHAR16
*SignatureStr
;
2001 EFI_GUID SignatureGuid
;
2002 HARDDRIVE_DEVICE_PATH
*Hd
;
2004 PartitionStr
= GetNextParamStr (&TextDeviceNode
);
2005 TypeStr
= GetNextParamStr (&TextDeviceNode
);
2006 SignatureStr
= GetNextParamStr (&TextDeviceNode
);
2007 StartStr
= GetNextParamStr (&TextDeviceNode
);
2008 SizeStr
= GetNextParamStr (&TextDeviceNode
);
2009 Hd
= (HARDDRIVE_DEVICE_PATH
*) CreateDeviceNode (
2012 sizeof (HARDDRIVE_DEVICE_PATH
)
2015 Hd
->PartitionNumber
= (UINT32
) Atoi (PartitionStr
);
2017 ZeroMem (Hd
->Signature
, 16);
2018 Hd
->MBRType
= (UINT8
) 0;
2020 if (StrCmp (TypeStr
, L
"None") == 0) {
2021 Hd
->SignatureType
= (UINT8
) 0;
2022 } else if (StrCmp (TypeStr
, L
"MBR") == 0) {
2023 Hd
->SignatureType
= SIGNATURE_TYPE_MBR
;
2026 Signature32
= (UINT32
) Xtoi (SignatureStr
);
2027 CopyMem (Hd
->Signature
, &Signature32
, sizeof (UINT32
));
2028 } else if (StrCmp (TypeStr
, L
"GUID") == 0) {
2029 Hd
->SignatureType
= SIGNATURE_TYPE_GUID
;
2032 StrToGuid (SignatureStr
, &SignatureGuid
);
2033 CopyMem (Hd
->Signature
, &SignatureGuid
, sizeof (EFI_GUID
));
2035 Hd
->SignatureType
= 0xff;
2039 Xtoi64 (StartStr
, &Hd
->PartitionStart
);
2040 Xtoi64 (SizeStr
, &Hd
->PartitionSize
);
2042 return (EFI_DEVICE_PATH_PROTOCOL
*) Hd
;
2046 EFI_DEVICE_PATH_PROTOCOL
*
2047 DevPathFromTextCDROM (
2048 IN CHAR16
*TextDeviceNode
2054 CDROM_DEVICE_PATH
*CDROM
;
2056 EntryStr
= GetNextParamStr (&TextDeviceNode
);
2057 StartStr
= GetNextParamStr (&TextDeviceNode
);
2058 SizeStr
= GetNextParamStr (&TextDeviceNode
);
2059 CDROM
= (CDROM_DEVICE_PATH
*) CreateDeviceNode (
2062 sizeof (CDROM_DEVICE_PATH
)
2065 CDROM
->BootEntry
= (UINT32
) Xtoi (EntryStr
);
2066 Xtoi64 (StartStr
, &CDROM
->PartitionStart
);
2067 Xtoi64 (SizeStr
, &CDROM
->PartitionSize
);
2069 return (EFI_DEVICE_PATH_PROTOCOL
*) CDROM
;
2073 EFI_DEVICE_PATH_PROTOCOL
*
2074 DevPathFromTextVenMEDIA (
2075 IN CHAR16
*TextDeviceNode
2078 return ConvertFromTextVendor (
2086 EFI_DEVICE_PATH_PROTOCOL
*
2087 DevPathFromTextFilePath (
2088 IN CHAR16
*TextDeviceNode
2091 FILEPATH_DEVICE_PATH
*File
;
2093 File
= (FILEPATH_DEVICE_PATH
*) CreateDeviceNode (
2096 sizeof (FILEPATH_DEVICE_PATH
) + (UINT16
) (StrLen (TextDeviceNode
) * 2)
2099 StrCpy (File
->PathName
, TextDeviceNode
);
2101 return (EFI_DEVICE_PATH_PROTOCOL
*) File
;
2105 EFI_DEVICE_PATH_PROTOCOL
*
2106 DevPathFromTextMedia (
2107 IN CHAR16
*TextDeviceNode
2111 MEDIA_PROTOCOL_DEVICE_PATH
*Media
;
2113 GuidStr
= GetNextParamStr (&TextDeviceNode
);
2114 Media
= (MEDIA_PROTOCOL_DEVICE_PATH
*) CreateDeviceNode (
2117 sizeof (MEDIA_PROTOCOL_DEVICE_PATH
)
2120 StrToGuid (GuidStr
, &Media
->Protocol
);
2122 return (EFI_DEVICE_PATH_PROTOCOL
*) Media
;
2126 EFI_DEVICE_PATH_PROTOCOL
*
2127 DevPathFromTextBBS (
2128 IN CHAR16
*TextDeviceNode
2135 BBS_BBS_DEVICE_PATH
*Bbs
;
2137 TypeStr
= GetNextParamStr (&TextDeviceNode
);
2138 IdStr
= GetNextParamStr (&TextDeviceNode
);
2139 FlagsStr
= GetNextParamStr (&TextDeviceNode
);
2140 Bbs
= (BBS_BBS_DEVICE_PATH
*) CreateDeviceNode (
2143 sizeof (BBS_BBS_DEVICE_PATH
) + (UINT16
) (StrLen (IdStr
))
2146 if (StrCmp (TypeStr
, L
"Floppy") == 0) {
2147 Bbs
->DeviceType
= BBS_TYPE_FLOPPY
;
2148 } else if (StrCmp (TypeStr
, L
"HD") == 0) {
2149 Bbs
->DeviceType
= BBS_TYPE_HARDDRIVE
;
2150 } else if (StrCmp (TypeStr
, L
"CDROM") == 0) {
2151 Bbs
->DeviceType
= BBS_TYPE_CDROM
;
2152 } else if (StrCmp (TypeStr
, L
"PCMCIA") == 0) {
2153 Bbs
->DeviceType
= BBS_TYPE_PCMCIA
;
2154 } else if (StrCmp (TypeStr
, L
"USB") == 0) {
2155 Bbs
->DeviceType
= BBS_TYPE_USB
;
2156 } else if (StrCmp (TypeStr
, L
"Network") == 0) {
2157 Bbs
->DeviceType
= BBS_TYPE_EMBEDDED_NETWORK
;
2159 Bbs
->DeviceType
= BBS_TYPE_UNKNOWN
;
2162 AsciiStr
= (UINT8
*) Bbs
->String
;
2163 StrToAscii (IdStr
, (CHAR8
**) &AsciiStr
);
2165 Bbs
->StatusFlag
= (UINT16
) Xtoi (FlagsStr
);
2167 return (EFI_DEVICE_PATH_PROTOCOL
*) Bbs
;
2170 GLOBAL_REMOVE_IF_UNREFERENCED DEVICE_PATH_FROM_TEXT_TABLE DevPathFromTextTable
[] = {
2171 {L
"Pci", DevPathFromTextPci
},
2172 {L
"PcCard", DevPathFromTextPcCard
},
2173 {L
"MemoryMapped", DevPathFromTextMemoryMapped
},
2174 {L
"VenHw", DevPathFromTextVenHw
},
2175 {L
"Ctrl", DevPathFromTextCtrl
},
2176 {L
"Acpi", DevPathFromTextAcpi
},
2177 {L
"PciRoot", DevPathFromTextPciRoot
},
2178 {L
"Floppy", DevPathFromTextFloppy
},
2179 {L
"Keyboard", DevPathFromTextKeyboard
},
2180 {L
"Serial", DevPathFromTextSerial
},
2181 {L
"ParallelPort", DevPathFromTextParallelPort
},
2182 {L
"AcpiEx", DevPathFromTextAcpiEx
},
2183 {L
"AcpiExp", DevPathFromTextAcpiExp
},
2184 {L
"Ata", DevPathFromTextAta
},
2185 {L
"Scsi", DevPathFromTextScsi
},
2186 {L
"Fibre", DevPathFromTextFibre
},
2187 {L
"I1394", DevPathFromText1394
},
2188 {L
"USB", DevPathFromTextUsb
},
2189 {L
"I2O", DevPathFromTextI2O
},
2190 {L
"Infiniband", DevPathFromTextInfiniband
},
2191 {L
"VenMsg", DevPathFromTextVenMsg
},
2192 {L
"VenPcAnsi", DevPathFromTextVenPcAnsi
},
2193 {L
"VenVt100", DevPathFromTextVenVt100
},
2194 {L
"VenVt100Plus", DevPathFromTextVenVt100Plus
},
2195 {L
"VenUtf8", DevPathFromTextVenUtf8
},
2196 {L
"UartFlowCtrl", DevPathFromTextUartFlowCtrl
},
2197 {L
"SAS", DevPathFromTextSAS
},
2198 {L
"DebugPort", DevPathFromTextDebugPort
},
2199 {L
"MAC", DevPathFromTextMAC
},
2200 {L
"IPv4", DevPathFromTextIPv4
},
2201 {L
"IPv6", DevPathFromTextIPv6
},
2202 {L
"Uart", DevPathFromTextUart
},
2203 {L
"UsbClass", DevPathFromTextUsbClass
},
2204 {L
"UsbAudio", DevPathFromTextUsbAudio
},
2205 {L
"UsbCDCControl", DevPathFromTextUsbCDCControl
},
2206 {L
"UsbHID", DevPathFromTextUsbHID
},
2207 {L
"UsbImage", DevPathFromTextUsbImage
},
2208 {L
"UsbPrinter", DevPathFromTextUsbPrinter
},
2209 {L
"UsbMassStorage", DevPathFromTextUsbMassStorage
},
2210 {L
"UsbHub", DevPathFromTextUsbHub
},
2211 {L
"UsbCDCData", DevPathFromTextUsbCDCData
},
2212 {L
"UsbSmartCard", DevPathFromTextUsbSmartCard
},
2213 {L
"UsbVideo", DevPathFromTextUsbVideo
},
2214 {L
"UsbDiagnostic", DevPathFromTextUsbDiagnostic
},
2215 {L
"UsbWireless", DevPathFromTextUsbWireless
},
2216 {L
"UsbDeviceFirmwareUpdate", DevPathFromTextUsbDeviceFirmwareUpdate
},
2217 {L
"UsbIrdaBridge", DevPathFromTextUsbIrdaBridge
},
2218 {L
"UsbTestAndMeasurement", DevPathFromTextUsbTestAndMeasurement
},
2219 {L
"UsbWwid", DevPathFromTextUsbWwid
},
2220 {L
"Unit", DevPathFromTextUnit
},
2221 {L
"iSCSI", DevPathFromTextiSCSI
},
2222 {L
"HD", DevPathFromTextHD
},
2223 {L
"CDROM", DevPathFromTextCDROM
},
2224 {L
"VenMEDIA", DevPathFromTextVenMEDIA
},
2225 {L
"Media", DevPathFromTextMedia
},
2226 {L
"BBS", DevPathFromTextBBS
},
2230 EFI_DEVICE_PATH_PROTOCOL
*
2231 ConvertTextToDeviceNode (
2232 IN CONST CHAR16
*TextDeviceNode
2236 Routine Description:
2237 Convert text to the binary representation of a device node.
2240 TextDeviceNode - TextDeviceNode points to the text representation of a device
2241 node. Conversion starts with the first character and continues
2242 until the first non-device node character.
2245 A pointer - Pointer to the EFI device node.
2246 NULL - If TextDeviceNode is NULL or there was insufficient memory or text unsupported.
2250 EFI_DEVICE_PATH_PROTOCOL
* (*DumpNode
) (CHAR16
*);
2252 EFI_DEVICE_PATH_PROTOCOL
*DeviceNode
;
2253 CHAR16
*DeviceNodeStr
;
2256 if ((TextDeviceNode
== NULL
) || (IS_NULL (*TextDeviceNode
))) {
2262 DeviceNodeStr
= StrDuplicate (TextDeviceNode
);
2264 for (Index
= 0; DevPathFromTextTable
[Index
].Function
; Index
++) {
2265 ParamStr
= GetParamByNodeName (DeviceNodeStr
, DevPathFromTextTable
[Index
].DevicePathNodeText
);
2266 if (ParamStr
!= NULL
) {
2267 DumpNode
= DevPathFromTextTable
[Index
].Function
;
2272 if (DumpNode
== NULL
) {
2276 DumpNode
= DevPathFromTextFilePath
;
2277 DeviceNode
= DumpNode (DeviceNodeStr
);
2279 DeviceNode
= DumpNode (ParamStr
);
2280 FreePool (ParamStr
);
2283 FreePool (DeviceNodeStr
);
2288 EFI_DEVICE_PATH_PROTOCOL
*
2289 ConvertTextToDevicePath (
2290 IN CONST CHAR16
*TextDevicePath
2294 Routine Description:
2295 Convert text to the binary representation of a device path.
2298 TextDevicePath - TextDevicePath points to the text representation of a device
2299 path. Conversion starts with the first character and continues
2300 until the first non-device node character.
2303 A pointer - Pointer to the allocated device path.
2304 NULL - If TextDeviceNode is NULL or there was insufficient memory.
2308 EFI_DEVICE_PATH_PROTOCOL
* (*DumpNode
) (CHAR16
*);
2310 EFI_DEVICE_PATH_PROTOCOL
*DeviceNode
;
2312 EFI_DEVICE_PATH_PROTOCOL
*NewDevicePath
;
2313 CHAR16
*DevicePathStr
;
2315 CHAR16
*DeviceNodeStr
;
2316 UINT8 IsInstanceEnd
;
2317 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
2319 if ((TextDevicePath
== NULL
) || (IS_NULL (*TextDevicePath
))) {
2323 DevicePath
= (EFI_DEVICE_PATH_PROTOCOL
*) AllocatePool (END_DEVICE_PATH_LENGTH
);
2324 SetDevicePathEndNode (DevicePath
);
2327 DeviceNodeStr
= NULL
;
2328 DevicePathStr
= StrDuplicate (TextDevicePath
);
2330 Str
= DevicePathStr
;
2331 while ((DeviceNodeStr
= GetNextDeviceNodeStr (&Str
, &IsInstanceEnd
)) != NULL
) {
2333 for (Index
= 0; DevPathFromTextTable
[Index
].Function
; Index
++) {
2334 ParamStr
= GetParamByNodeName (DeviceNodeStr
, DevPathFromTextTable
[Index
].DevicePathNodeText
);
2335 if (ParamStr
!= NULL
) {
2336 DumpNode
= DevPathFromTextTable
[Index
].Function
;
2341 if (DumpNode
== NULL
) {
2345 DumpNode
= DevPathFromTextFilePath
;
2346 DeviceNode
= DumpNode (DeviceNodeStr
);
2348 DeviceNode
= DumpNode (ParamStr
);
2349 FreePool (ParamStr
);
2352 NewDevicePath
= AppendDeviceNodeProtocolInterface (DevicePath
, DeviceNode
);
2353 FreePool (DevicePath
);
2354 FreePool (DeviceNode
);
2355 DevicePath
= NewDevicePath
;
2357 if (IsInstanceEnd
) {
2358 DeviceNode
= (EFI_DEVICE_PATH_PROTOCOL
*) AllocatePool (END_DEVICE_PATH_LENGTH
);
2359 SetDevicePathInstanceEndNode (DeviceNode
);
2361 NewDevicePath
= AppendDeviceNodeProtocolInterface (DevicePath
, DeviceNode
);
2362 FreePool (DevicePath
);
2363 FreePool (DeviceNode
);
2364 DevicePath
= NewDevicePath
;
2368 FreePool (DevicePathStr
);