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.
23 // Include common header file for this module.
25 #include "CommonHeader.h"
27 #include "DevicePath.h"
50 Length
= StrLen ((CHAR16
*) Src
);
52 ReturnStr
= AllocateCopyPool ((Length
+ 1) * sizeof (CHAR16
), (VOID
*) Src
);
66 Get parameter in a pair of parentheses follow the given node name.
67 For example, given the "Pci(0,1)" and NodeName "Pci", it returns "0,1".
70 Str - Device Path Text
71 NodeName - Name of the node
74 Parameter text for the node
81 UINTN ParameterLength
;
84 // Check whether the node name matchs
86 NodeNameLength
= StrLen (NodeName
);
87 if (CompareMem (Str
, NodeName
, NodeNameLength
* sizeof (CHAR16
)) != 0) {
91 ParamStr
= Str
+ NodeNameLength
;
92 if (!IS_LEFT_PARENTH (*ParamStr
)) {
97 // Skip the found '(' and find first occurrence of ')'
101 StrPointer
= ParamStr
;
102 while (!IS_NULL (*StrPointer
)) {
103 if (IS_RIGHT_PARENTH (*StrPointer
)) {
109 if (IS_NULL (*StrPointer
)) {
116 ParamStr
= AllocateCopyPool ((ParameterLength
+ 1) * sizeof (CHAR16
), ParamStr
);
117 if (ParamStr
== NULL
) {
121 // Terminate the parameter string
123 ParamStr
[ParameterLength
] = L
'\0';
131 IN OUT CHAR16
**List
,
137 Get current sub-string from a string list, before return
138 the list header is moved to next sub-string. The sub-string is separated
139 by the specified character. For example, the separator is ',', the string
140 list is "2,0,3", it returns "2", the remain list move to "2,3"
143 List - A string list separated by the specified separator
144 Separator - The separator character
147 pointer - The current sub-string
157 if (IS_NULL (*Str
)) {
162 // Find first occurrence of the separator
164 while (!IS_NULL (*Str
)) {
165 if (*Str
== Separator
) {
171 if (*Str
== Separator
) {
173 // Find a sub-string, terminate it
180 // Move to next sub-string
194 // The separator is comma
196 return SplitStr (List
, L
',');
201 GetNextDeviceNodeStr (
202 IN OUT CHAR16
**DevicePath
,
203 OUT BOOLEAN
*IsInstanceEnd
208 Get one device node from entire device path text.
211 Str - The entire device path text string
212 IsInstanceEnd - This node is the end of a device path instance
215 a pointer - A device node text
216 NULL - No more device node available
222 UINTN ParenthesesStack
;
225 if (IS_NULL (*Str
)) {
230 // Skip the leading '/', '(', ')' and ','
232 while (!IS_NULL (*Str
)) {
233 if (!IS_SLASH (*Str
) &&
235 !IS_LEFT_PARENTH (*Str
) &&
236 !IS_RIGHT_PARENTH (*Str
)) {
245 // Scan for the separator of this device node, '/' or ','
247 ParenthesesStack
= 0;
248 while (!IS_NULL (*Str
)) {
249 if ((IS_COMMA (*Str
) || IS_SLASH (*Str
)) && (ParenthesesStack
== 0)) {
253 if (IS_LEFT_PARENTH (*Str
)) {
255 } else if (IS_RIGHT_PARENTH (*Str
)) {
262 if (ParenthesesStack
!= 0) {
264 // The '(' doesn't pair with ')', invalid device path text
269 if (IS_COMMA (*Str
)) {
270 *IsInstanceEnd
= TRUE
;
274 *IsInstanceEnd
= FALSE
;
275 if (!IS_NULL (*Str
)) {
295 Determines if a Unicode character is a hexadecimal digit.
296 The test is case insensitive.
299 Digit - Pointer to byte that receives the value of the hex character.
300 Char - Unicode character to test.
303 TRUE - If the character is a hexadecimal digit.
308 if ((Char
>= L
'0') && (Char
<= L
'9')) {
309 *Digit
= (UINT8
) (Char
- L
'0');
313 if ((Char
>= L
'A') && (Char
<= L
'F')) {
314 *Digit
= (UINT8
) (Char
- L
'A' + 0x0A);
318 if ((Char
>= L
'a') && (Char
<= L
'f')) {
319 *Digit
= (UINT8
) (Char
- L
'a' + 0x0A);
332 OUT UINTN
*ConvertedStrLen OPTIONAL
337 Converts Unicode string to binary buffer.
338 The conversion may be partial.
339 The first character in the string that is not hex digit stops the conversion.
340 At a minimum, any blob of data could be represented as a hex string.
343 Buf - Pointer to buffer that receives the data.
344 Len - Length in bytes of the buffer to hold converted data.
345 If routine return with EFI_SUCCESS, containing length of converted data.
346 If routine return with EFI_BUFFER_TOO_SMALL, containg length of buffer desired.
347 Str - String to be converted from.
348 ConvertedStrLen - Length of the Hex String consumed.
351 EFI_SUCCESS: Routine Success.
352 EFI_BUFFER_TOO_SMALL: The buffer is too small to hold converted data.
364 // Find out how many hex characters the string has.
366 for (Idx
= 0, HexCnt
= 0; IsHexDigit (&Digit
, Str
[Idx
]); Idx
++, HexCnt
++);
373 // Two Unicode characters make up 1 buffer byte. Round up.
375 BufferLength
= (HexCnt
+ 1) / 2;
378 // Test if buffer is passed enough.
380 if (BufferLength
> (*Len
)) {
382 return EFI_BUFFER_TOO_SMALL
;
387 for (Idx
= 0; Idx
< HexCnt
; Idx
++) {
389 IsHexDigit (&Digit
, Str
[HexCnt
- 1 - Idx
]);
392 // For odd charaters, write the lower nibble for each buffer byte,
393 // and for even characters, the upper nibble.
395 if ((Idx
& 1) == 0) {
400 Byte
= (UINT8
) (Byte
| Digit
<< 4);
406 if (ConvertedStrLen
!= NULL
) {
407 *ConvertedStrLen
= HexCnt
;
421 Skip the leading white space and '0x' or '0X' of a hex string
431 // skip preceeding white space
433 while (*Str
&& *Str
== ' ') {
437 // skip preceeding zeros
439 while (*Str
&& *Str
== '0') {
443 // skip preceeding character 'x' or 'X'
445 if (*Str
&& (*Str
== 'x' || *Str
== 'X')) {
461 Convert hex string to uint
474 ASSERT (Str
!= NULL
);
477 // convert hex digits
480 Length
= sizeof (UINTN
);
481 HexStringToBuf ((UINT8
*) &Rvalue
, &Length
, TrimHexStr (Str
), NULL
);
496 Convert hex string to 64 bit data.
509 Length
= sizeof (UINT64
);
510 HexStringToBuf ((UINT8
*) Data
, &Length
, TrimHexStr (Str
), NULL
);
522 Convert decimal string to uint
537 ASSERT (str
!= NULL
);
539 High
= (UINTN
) -1 / 10;
540 Low
= (UINTN
) -1 % 10;
542 // skip preceeding white space
544 while (*str
&& *str
== ' ') {
553 if (Char
>= '0' && Char
<= '9') {
554 if ((Rvalue
> High
|| Rvalue
== High
) && (Char
- '0' > (INTN
) Low
)) {
558 Rvalue
= (Rvalue
* 10) + Char
- '0';
573 IN UINTN BufferLength
,
583 // Two hex char make up one byte
585 StrLength
= BufferLength
* sizeof (CHAR16
);
587 for(Index
= 0; Index
< StrLength
; Index
++, Str
++) {
589 IsHexDigit (&Digit
, *Str
);
592 // For odd charaters, write the upper nibble for each buffer byte,
593 // and for even characters, the lower nibble.
595 if ((Index
& 1) == 0) {
596 Byte
= (UINT8
) (Digit
<< 4);
598 Byte
= Buf
[Index
/ 2];
600 Byte
= (UINT8
) (Byte
| Digit
);
603 Buf
[Index
/ 2] = Byte
;
617 UINTN ConvertedStrLen
;
620 BufferLength
= sizeof (Guid
->Data1
);
621 Status
= HexStringToBuf ((UINT8
*) &Guid
->Data1
, &BufferLength
, Str
, &ConvertedStrLen
);
622 if (EFI_ERROR (Status
)) {
625 Str
+= ConvertedStrLen
;
626 if (IS_HYPHEN (*Str
)) {
629 return EFI_UNSUPPORTED
;
632 BufferLength
= sizeof (Guid
->Data2
);
633 Status
= HexStringToBuf ((UINT8
*) &Guid
->Data2
, &BufferLength
, Str
, &ConvertedStrLen
);
634 if (EFI_ERROR (Status
)) {
637 Str
+= ConvertedStrLen
;
638 if (IS_HYPHEN (*Str
)) {
641 return EFI_UNSUPPORTED
;
644 BufferLength
= sizeof (Guid
->Data3
);
645 Status
= HexStringToBuf ((UINT8
*) &Guid
->Data3
, &BufferLength
, Str
, &ConvertedStrLen
);
646 if (EFI_ERROR (Status
)) {
649 Str
+= ConvertedStrLen
;
650 if (IS_HYPHEN (*Str
)) {
653 return EFI_UNSUPPORTED
;
656 StrToBuf (&Guid
->Data4
[0], 2, Str
);
658 // Skip 2 byte hex chars
662 if (IS_HYPHEN (*Str
)) {
665 return EFI_UNSUPPORTED
;
667 StrToBuf (&Guid
->Data4
[2], 6, Str
);
676 OUT EFI_IPv4_ADDRESS
*IPv4Addr
681 for (Index
= 0; Index
< 4; Index
++) {
682 IPv4Addr
->Addr
[Index
] = (UINT8
) Atoi (SplitStr (Str
, L
'.'));
690 OUT EFI_IPv6_ADDRESS
*IPv6Addr
696 for (Index
= 0; Index
< 8; Index
++) {
697 Data
= (UINT16
) Xtoi (SplitStr (Str
, L
':'));
698 IPv6Addr
->Addr
[Index
* 2] = (UINT8
) (Data
>> 8);
699 IPv6Addr
->Addr
[Index
* 2 + 1] = (UINT8
) (Data
& 0xff);
707 IN OUT CHAR8
**AsciiStr
713 while (!IS_NULL (*Str
)) {
714 *(Dest
++) = (CHAR8
) *(Str
++);
719 // Return the string next to it
721 *AsciiStr
= Dest
+ 1;
725 EFI_DEVICE_PATH_PROTOCOL
*
727 IN CHAR16
*TextDeviceNode
732 PCI_DEVICE_PATH
*Pci
;
734 FunctionStr
= GetNextParamStr (&TextDeviceNode
);
735 DeviceStr
= GetNextParamStr (&TextDeviceNode
);
736 Pci
= (PCI_DEVICE_PATH
*) CreateDeviceNode (
737 HARDWARE_DEVICE_PATH
,
739 sizeof (PCI_DEVICE_PATH
)
742 Pci
->Function
= (UINT8
) Xtoi (FunctionStr
);
743 Pci
->Device
= (UINT8
) Xtoi (DeviceStr
);
745 return (EFI_DEVICE_PATH_PROTOCOL
*) Pci
;
749 EFI_DEVICE_PATH_PROTOCOL
*
750 DevPathFromTextPcCard (
751 IN CHAR16
*TextDeviceNode
754 CHAR16
*FunctionNumberStr
;
755 PCCARD_DEVICE_PATH
*Pccard
;
757 FunctionNumberStr
= GetNextParamStr (&TextDeviceNode
);
758 Pccard
= (PCCARD_DEVICE_PATH
*) CreateDeviceNode (
759 HARDWARE_DEVICE_PATH
,
761 sizeof (PCCARD_DEVICE_PATH
)
764 Pccard
->FunctionNumber
= (UINT8
) Xtoi (FunctionNumberStr
);
766 return (EFI_DEVICE_PATH_PROTOCOL
*) Pccard
;
770 EFI_DEVICE_PATH_PROTOCOL
*
771 DevPathFromTextMemoryMapped (
772 IN CHAR16
*TextDeviceNode
775 CHAR16
*StartingAddressStr
;
776 CHAR16
*EndingAddressStr
;
777 MEMMAP_DEVICE_PATH
*MemMap
;
779 StartingAddressStr
= GetNextParamStr (&TextDeviceNode
);
780 EndingAddressStr
= GetNextParamStr (&TextDeviceNode
);
781 MemMap
= (MEMMAP_DEVICE_PATH
*) CreateDeviceNode (
782 HARDWARE_DEVICE_PATH
,
784 sizeof (MEMMAP_DEVICE_PATH
)
787 MemMap
->MemoryType
= 0;
789 Xtoi64 (StartingAddressStr
, &MemMap
->StartingAddress
);
790 Xtoi64 (EndingAddressStr
, &MemMap
->EndingAddress
);
792 return (EFI_DEVICE_PATH_PROTOCOL
*) MemMap
;
796 EFI_DEVICE_PATH_PROTOCOL
*
797 ConvertFromTextVendor (
798 IN CHAR16
*TextDeviceNode
,
806 VENDOR_DEVICE_PATH
*Vendor
;
808 GuidStr
= GetNextParamStr (&TextDeviceNode
);
810 DataStr
= GetNextParamStr (&TextDeviceNode
);
811 Length
= StrLen (DataStr
);
813 // Two hex characters make up 1 buffer byte
815 Length
= (Length
+ 1) / 2;
817 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
820 sizeof (VENDOR_DEVICE_PATH
) + (UINT16
) Length
823 StrToGuid (GuidStr
, &Vendor
->Guid
);
824 StrToBuf (((UINT8
*) Vendor
) + sizeof (VENDOR_DEVICE_PATH
), Length
, DataStr
);
826 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
830 EFI_DEVICE_PATH_PROTOCOL
*
831 DevPathFromTextVenHw (
832 IN CHAR16
*TextDeviceNode
835 return ConvertFromTextVendor (
837 HARDWARE_DEVICE_PATH
,
843 EFI_DEVICE_PATH_PROTOCOL
*
844 DevPathFromTextCtrl (
845 IN CHAR16
*TextDeviceNode
848 CHAR16
*ControllerStr
;
849 CONTROLLER_DEVICE_PATH
*Controller
;
851 ControllerStr
= GetNextParamStr (&TextDeviceNode
);
852 Controller
= (CONTROLLER_DEVICE_PATH
*) CreateDeviceNode (
853 HARDWARE_DEVICE_PATH
,
855 sizeof (CONTROLLER_DEVICE_PATH
)
857 Controller
->ControllerNumber
= (UINT32
) Xtoi (ControllerStr
);
859 return (EFI_DEVICE_PATH_PROTOCOL
*) Controller
;
863 EFI_DEVICE_PATH_PROTOCOL
*
864 DevPathFromTextAcpi (
865 IN CHAR16
*TextDeviceNode
870 ACPI_HID_DEVICE_PATH
*Acpi
;
872 HIDStr
= GetNextParamStr (&TextDeviceNode
);
873 UIDStr
= GetNextParamStr (&TextDeviceNode
);
874 Acpi
= (ACPI_HID_DEVICE_PATH
*) CreateDeviceNode (
877 sizeof (ACPI_HID_DEVICE_PATH
)
880 if ((HIDStr
[0] == L
'P') && (HIDStr
[1] == L
'N') && (HIDStr
[2] == L
'P')) {
884 Acpi
->HID
= EISA_PNP_ID (Xtoi (HIDStr
));
885 Acpi
->UID
= (UINT32
) Xtoi (UIDStr
);
887 return (EFI_DEVICE_PATH_PROTOCOL
*) Acpi
;
891 EFI_DEVICE_PATH_PROTOCOL
*
892 ConvertFromTextAcpi (
893 IN CHAR16
*TextDeviceNode
,
898 ACPI_HID_DEVICE_PATH
*Acpi
;
900 UIDStr
= GetNextParamStr (&TextDeviceNode
);
901 Acpi
= (ACPI_HID_DEVICE_PATH
*) CreateDeviceNode (
904 sizeof (ACPI_HID_DEVICE_PATH
)
908 Acpi
->UID
= (UINT32
) Xtoi (UIDStr
);
910 return (EFI_DEVICE_PATH_PROTOCOL
*) Acpi
;
914 EFI_DEVICE_PATH_PROTOCOL
*
915 DevPathFromTextPciRoot (
916 IN CHAR16
*TextDeviceNode
919 return ConvertFromTextAcpi (TextDeviceNode
, 0x0a0341d0);
923 EFI_DEVICE_PATH_PROTOCOL
*
924 DevPathFromTextFloppy (
925 IN CHAR16
*TextDeviceNode
928 return ConvertFromTextAcpi (TextDeviceNode
, 0x060441d0);
932 EFI_DEVICE_PATH_PROTOCOL
*
933 DevPathFromTextKeyboard (
934 IN CHAR16
*TextDeviceNode
937 return ConvertFromTextAcpi (TextDeviceNode
, 0x030141d0);
941 EFI_DEVICE_PATH_PROTOCOL
*
942 DevPathFromTextSerial (
943 IN CHAR16
*TextDeviceNode
946 return ConvertFromTextAcpi (TextDeviceNode
, 0x050141d0);
950 EFI_DEVICE_PATH_PROTOCOL
*
951 DevPathFromTextParallelPort (
952 IN CHAR16
*TextDeviceNode
955 return ConvertFromTextAcpi (TextDeviceNode
, 0x040141d0);
959 EFI_DEVICE_PATH_PROTOCOL
*
960 DevPathFromTextAcpiEx (
961 IN CHAR16
*TextDeviceNode
972 ACPI_EXTENDED_HID_DEVICE_PATH_WITH_STR
*AcpiExt
;
974 HIDStr
= GetNextParamStr (&TextDeviceNode
);
975 CIDStr
= GetNextParamStr (&TextDeviceNode
);
976 UIDStr
= GetNextParamStr (&TextDeviceNode
);
977 HIDSTRStr
= GetNextParamStr (&TextDeviceNode
);
978 CIDSTRStr
= GetNextParamStr (&TextDeviceNode
);
979 UIDSTRStr
= GetNextParamStr (&TextDeviceNode
);
981 Length
= (UINT16
) (sizeof (ACPI_EXTENDED_HID_DEVICE_PATH
) + StrLen (HIDSTRStr
) + 1);
982 Length
= (UINT16
) (Length
+ StrLen (UIDSTRStr
) + 1);
983 Length
= (UINT16
) (Length
+ StrLen (CIDSTRStr
) + 1);
984 AcpiExt
= (ACPI_EXTENDED_HID_DEVICE_PATH_WITH_STR
*) CreateDeviceNode (
990 if ((HIDStr
[0] == L
'P') && (HIDStr
[1] == L
'N') && (HIDStr
[2] == L
'P')) {
992 AcpiExt
->HID
= EISA_PNP_ID (Xtoi (HIDStr
));
994 AcpiExt
->HID
= (UINT32
) Xtoi (HIDStr
);
997 AcpiExt
->UID
= (UINT32
) Xtoi (UIDStr
);
998 AcpiExt
->CID
= (UINT32
) Xtoi (CIDStr
);
1000 AsciiStr
= AcpiExt
->HidUidCidStr
;
1001 StrToAscii (HIDSTRStr
, &AsciiStr
);
1002 StrToAscii (UIDSTRStr
, &AsciiStr
);
1003 StrToAscii (CIDSTRStr
, &AsciiStr
);
1005 return (EFI_DEVICE_PATH_PROTOCOL
*) AcpiExt
;
1009 EFI_DEVICE_PATH_PROTOCOL
*
1010 DevPathFromTextAcpiExp (
1011 IN CHAR16
*TextDeviceNode
1019 ACPI_EXTENDED_HID_DEVICE_PATH_WITH_STR
*AcpiExt
;
1021 HIDStr
= GetNextParamStr (&TextDeviceNode
);
1022 CIDStr
= GetNextParamStr (&TextDeviceNode
);
1023 UIDSTRStr
= GetNextParamStr (&TextDeviceNode
);
1024 Length
= sizeof (ACPI_EXTENDED_HID_DEVICE_PATH
) + (UINT16
) StrLen (UIDSTRStr
) + 3;
1025 AcpiExt
= (ACPI_EXTENDED_HID_DEVICE_PATH_WITH_STR
*) CreateDeviceNode (
1031 if ((HIDStr
[0] == L
'P') && (HIDStr
[1] == L
'N') && (HIDStr
[2] == L
'P')) {
1033 AcpiExt
->HID
= EISA_PNP_ID (Xtoi (HIDStr
));
1035 AcpiExt
->HID
= (UINT32
) Xtoi (HIDStr
);
1039 AcpiExt
->CID
= (UINT32
) Xtoi (CIDStr
);
1041 AsciiStr
= AcpiExt
->HidUidCidStr
;
1043 // HID string is NULL
1047 // Convert UID string
1050 StrToAscii (UIDSTRStr
, &AsciiStr
);
1052 // CID string is NULL
1056 return (EFI_DEVICE_PATH_PROTOCOL
*) AcpiExt
;
1060 EFI_DEVICE_PATH_PROTOCOL
*
1061 DevPathFromTextAta (
1062 IN CHAR16
*TextDeviceNode
1065 CHAR16
*PrimarySecondaryStr
;
1066 CHAR16
*SlaveMasterStr
;
1068 ATAPI_DEVICE_PATH
*Atapi
;
1070 Atapi
= (ATAPI_DEVICE_PATH
*) CreateDeviceNode (
1071 MESSAGING_DEVICE_PATH
,
1073 sizeof (ATAPI_DEVICE_PATH
)
1076 PrimarySecondaryStr
= GetNextParamStr (&TextDeviceNode
);
1077 SlaveMasterStr
= GetNextParamStr (&TextDeviceNode
);
1078 LunStr
= GetNextParamStr (&TextDeviceNode
);
1080 Atapi
->PrimarySecondary
= (UINT8
) ((StrCmp (PrimarySecondaryStr
, L
"Primary") == 0) ? 0 : 1);
1081 Atapi
->SlaveMaster
= (UINT8
) ((StrCmp (SlaveMasterStr
, L
"Master") == 0) ? 0 : 1);
1082 Atapi
->Lun
= (UINT16
) Xtoi (LunStr
);
1084 return (EFI_DEVICE_PATH_PROTOCOL
*) Atapi
;
1088 EFI_DEVICE_PATH_PROTOCOL
*
1089 DevPathFromTextScsi (
1090 IN CHAR16
*TextDeviceNode
1095 SCSI_DEVICE_PATH
*Scsi
;
1097 PunStr
= GetNextParamStr (&TextDeviceNode
);
1098 LunStr
= GetNextParamStr (&TextDeviceNode
);
1099 Scsi
= (SCSI_DEVICE_PATH
*) CreateDeviceNode (
1100 MESSAGING_DEVICE_PATH
,
1102 sizeof (SCSI_DEVICE_PATH
)
1105 Scsi
->Pun
= (UINT16
) Xtoi (PunStr
);
1106 Scsi
->Lun
= (UINT16
) Xtoi (LunStr
);
1108 return (EFI_DEVICE_PATH_PROTOCOL
*) Scsi
;
1112 EFI_DEVICE_PATH_PROTOCOL
*
1113 DevPathFromTextFibre (
1114 IN CHAR16
*TextDeviceNode
1119 FIBRECHANNEL_DEVICE_PATH
*Fibre
;
1121 WWNStr
= GetNextParamStr (&TextDeviceNode
);
1122 LunStr
= GetNextParamStr (&TextDeviceNode
);
1123 Fibre
= (FIBRECHANNEL_DEVICE_PATH
*) CreateDeviceNode (
1124 MESSAGING_DEVICE_PATH
,
1125 MSG_FIBRECHANNEL_DP
,
1126 sizeof (FIBRECHANNEL_DEVICE_PATH
)
1129 Fibre
->Reserved
= 0;
1130 Xtoi64 (WWNStr
, &Fibre
->WWN
);
1131 Xtoi64 (LunStr
, &Fibre
->Lun
);
1133 return (EFI_DEVICE_PATH_PROTOCOL
*) Fibre
;
1137 EFI_DEVICE_PATH_PROTOCOL
*
1138 DevPathFromText1394 (
1139 IN CHAR16
*TextDeviceNode
1143 F1394_DEVICE_PATH
*F1394
;
1145 GuidStr
= GetNextParamStr (&TextDeviceNode
);
1146 F1394
= (F1394_DEVICE_PATH
*) CreateDeviceNode (
1147 MESSAGING_DEVICE_PATH
,
1149 sizeof (F1394_DEVICE_PATH
)
1152 F1394
->Reserved
= 0;
1153 Xtoi64 (GuidStr
, &F1394
->Guid
);
1155 return (EFI_DEVICE_PATH_PROTOCOL
*) F1394
;
1159 EFI_DEVICE_PATH_PROTOCOL
*
1160 DevPathFromTextUsb (
1161 IN CHAR16
*TextDeviceNode
1165 CHAR16
*InterfaceStr
;
1166 USB_DEVICE_PATH
*Usb
;
1168 PortStr
= GetNextParamStr (&TextDeviceNode
);
1169 InterfaceStr
= GetNextParamStr (&TextDeviceNode
);
1170 Usb
= (USB_DEVICE_PATH
*) CreateDeviceNode (
1171 MESSAGING_DEVICE_PATH
,
1173 sizeof (USB_DEVICE_PATH
)
1176 Usb
->ParentPortNumber
= (UINT8
) Xtoi (PortStr
);
1177 Usb
->InterfaceNumber
= (UINT8
) Xtoi (InterfaceStr
);
1179 return (EFI_DEVICE_PATH_PROTOCOL
*) Usb
;
1183 EFI_DEVICE_PATH_PROTOCOL
*
1184 DevPathFromTextI2O (
1185 IN CHAR16
*TextDeviceNode
1189 I2O_DEVICE_PATH
*I2O
;
1191 TIDStr
= GetNextParamStr (&TextDeviceNode
);
1192 I2O
= (I2O_DEVICE_PATH
*) CreateDeviceNode (
1193 MESSAGING_DEVICE_PATH
,
1195 sizeof (I2O_DEVICE_PATH
)
1198 I2O
->Tid
= (UINT32
) Xtoi (TIDStr
);
1200 return (EFI_DEVICE_PATH_PROTOCOL
*) I2O
;
1204 EFI_DEVICE_PATH_PROTOCOL
*
1205 DevPathFromTextInfiniband (
1206 IN CHAR16
*TextDeviceNode
1215 INFINIBAND_DEVICE_PATH
*InfiniBand
;
1217 FlagsStr
= GetNextParamStr (&TextDeviceNode
);
1218 GuidStr
= GetNextParamStr (&TextDeviceNode
);
1219 SidStr
= GetNextParamStr (&TextDeviceNode
);
1220 TidStr
= GetNextParamStr (&TextDeviceNode
);
1221 DidStr
= GetNextParamStr (&TextDeviceNode
);
1222 InfiniBand
= (INFINIBAND_DEVICE_PATH
*) CreateDeviceNode (
1223 MESSAGING_DEVICE_PATH
,
1225 sizeof (INFINIBAND_DEVICE_PATH
)
1228 InfiniBand
->ResourceFlags
= (UINT32
) Xtoi (FlagsStr
);
1229 StrToGuid (GuidStr
, &PortGid
);
1230 CopyMem (InfiniBand
->PortGid
, &PortGid
, sizeof (EFI_GUID
));
1231 Xtoi64 (SidStr
, &InfiniBand
->ServiceId
);
1232 Xtoi64 (TidStr
, &InfiniBand
->TargetPortId
);
1233 Xtoi64 (DidStr
, &InfiniBand
->DeviceId
);
1235 return (EFI_DEVICE_PATH_PROTOCOL
*) InfiniBand
;
1239 EFI_DEVICE_PATH_PROTOCOL
*
1240 DevPathFromTextVenMsg (
1241 IN CHAR16
*TextDeviceNode
1244 return ConvertFromTextVendor (
1246 MESSAGING_DEVICE_PATH
,
1252 EFI_DEVICE_PATH_PROTOCOL
*
1253 DevPathFromTextVenPcAnsi (
1254 IN CHAR16
*TextDeviceNode
1257 VENDOR_DEVICE_PATH
*Vendor
;
1259 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
1260 MESSAGING_DEVICE_PATH
,
1262 sizeof (VENDOR_DEVICE_PATH
));
1263 CopyGuid (&Vendor
->Guid
, &gEfiPcAnsiGuid
);
1265 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
1269 EFI_DEVICE_PATH_PROTOCOL
*
1270 DevPathFromTextVenVt100 (
1271 IN CHAR16
*TextDeviceNode
1274 VENDOR_DEVICE_PATH
*Vendor
;
1276 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
1277 MESSAGING_DEVICE_PATH
,
1279 sizeof (VENDOR_DEVICE_PATH
));
1280 CopyGuid (&Vendor
->Guid
, &gEfiVT100Guid
);
1282 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
1286 EFI_DEVICE_PATH_PROTOCOL
*
1287 DevPathFromTextVenVt100Plus (
1288 IN CHAR16
*TextDeviceNode
1291 VENDOR_DEVICE_PATH
*Vendor
;
1293 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
1294 MESSAGING_DEVICE_PATH
,
1296 sizeof (VENDOR_DEVICE_PATH
));
1297 CopyGuid (&Vendor
->Guid
, &gEfiVT100PlusGuid
);
1299 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
1303 EFI_DEVICE_PATH_PROTOCOL
*
1304 DevPathFromTextVenUtf8 (
1305 IN CHAR16
*TextDeviceNode
1308 VENDOR_DEVICE_PATH
*Vendor
;
1310 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
1311 MESSAGING_DEVICE_PATH
,
1313 sizeof (VENDOR_DEVICE_PATH
));
1314 CopyGuid (&Vendor
->Guid
, &gEfiVTUTF8Guid
);
1316 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
1320 EFI_DEVICE_PATH_PROTOCOL
*
1321 DevPathFromTextUartFlowCtrl (
1322 IN CHAR16
*TextDeviceNode
1326 UART_FLOW_CONTROL_DEVICE_PATH
*UartFlowControl
;
1328 ValueStr
= GetNextParamStr (&TextDeviceNode
);
1329 UartFlowControl
= (UART_FLOW_CONTROL_DEVICE_PATH
*) CreateDeviceNode (
1330 MESSAGING_DEVICE_PATH
,
1332 sizeof (UART_FLOW_CONTROL_DEVICE_PATH
)
1335 CopyGuid (&UartFlowControl
->Guid
, &mEfiDevicePathMessagingUartFlowControlGuid
);
1336 if (StrCmp (ValueStr
, L
"XonXoff") == 0) {
1337 UartFlowControl
->FlowControlMap
= 2;
1338 } else if (StrCmp (ValueStr
, L
"Hardware") == 0) {
1339 UartFlowControl
->FlowControlMap
= 1;
1341 UartFlowControl
->FlowControlMap
= 0;
1344 return (EFI_DEVICE_PATH_PROTOCOL
*) UartFlowControl
;
1348 EFI_DEVICE_PATH_PROTOCOL
*
1349 DevPathFromTextSAS (
1350 IN CHAR16
*TextDeviceNode
1357 CHAR16
*LocationStr
;
1359 CHAR16
*DriveBayStr
;
1360 CHAR16
*ReservedStr
;
1362 SAS_DEVICE_PATH
*Sas
;
1364 AddressStr
= GetNextParamStr (&TextDeviceNode
);
1365 LunStr
= GetNextParamStr (&TextDeviceNode
);
1366 RTPStr
= GetNextParamStr (&TextDeviceNode
);
1367 SASSATAStr
= GetNextParamStr (&TextDeviceNode
);
1368 LocationStr
= GetNextParamStr (&TextDeviceNode
);
1369 ConnectStr
= GetNextParamStr (&TextDeviceNode
);
1370 DriveBayStr
= GetNextParamStr (&TextDeviceNode
);
1371 ReservedStr
= GetNextParamStr (&TextDeviceNode
);
1373 Sas
= (SAS_DEVICE_PATH
*) CreateDeviceNode (
1374 MESSAGING_DEVICE_PATH
,
1376 sizeof (SAS_DEVICE_PATH
)
1379 CopyGuid (&Sas
->Guid
, &mEfiDevicePathMessagingSASGuid
);
1380 Xtoi64 (AddressStr
, &Sas
->SasAddress
);
1381 Xtoi64 (LunStr
, &Sas
->Lun
);
1382 Sas
->RelativeTargetPort
= (UINT16
) Xtoi (RTPStr
);
1383 if (StrCmp (SASSATAStr
, L
"NoTopology") == 0)
1386 if (StrCmp (DriveBayStr
, L
"0") == 0) {
1390 Info
|= (Xtoi (DriveBayStr
) << 8);
1393 if (StrCmp (SASSATAStr
, L
"SATA") == 0) {
1397 if (StrCmp (LocationStr
, L
"External") == 0) {
1401 if (StrCmp (ConnectStr
, L
"Expanded") == 0) {
1406 Sas
->DeviceTopology
= Info
;
1407 Sas
->Reserved
= (UINT32
) Xtoi (ReservedStr
);
1409 return (EFI_DEVICE_PATH_PROTOCOL
*) Sas
;
1413 EFI_DEVICE_PATH_PROTOCOL
*
1414 DevPathFromTextDebugPort (
1415 IN CHAR16
*TextDeviceNode
1418 VENDOR_DEFINED_MESSAGING_DEVICE_PATH
*Vend
;
1420 Vend
= (VENDOR_DEFINED_MESSAGING_DEVICE_PATH
*) CreateDeviceNode (
1421 MESSAGING_DEVICE_PATH
,
1423 sizeof (VENDOR_DEFINED_MESSAGING_DEVICE_PATH
)
1426 CopyGuid (&Vend
->Guid
, &gEfiDebugPortProtocolGuid
);
1428 return (EFI_DEVICE_PATH_PROTOCOL
*) Vend
;
1432 EFI_DEVICE_PATH_PROTOCOL
*
1433 DevPathFromTextMAC (
1434 IN CHAR16
*TextDeviceNode
1440 MAC_ADDR_DEVICE_PATH
*MAC
;
1442 AddressStr
= GetNextParamStr (&TextDeviceNode
);
1443 IfTypeStr
= GetNextParamStr (&TextDeviceNode
);
1444 MAC
= (MAC_ADDR_DEVICE_PATH
*) CreateDeviceNode (
1445 MESSAGING_DEVICE_PATH
,
1447 sizeof (MAC_ADDR_DEVICE_PATH
)
1450 MAC
->IfType
= (UINT8
) Xtoi (IfTypeStr
);
1452 Length
= sizeof (EFI_MAC_ADDRESS
);
1453 StrToBuf (&MAC
->MacAddress
.Addr
[0], Length
, AddressStr
);
1455 return (EFI_DEVICE_PATH_PROTOCOL
*) MAC
;
1459 EFI_DEVICE_PATH_PROTOCOL
*
1460 DevPathFromTextIPv4 (
1461 IN CHAR16
*TextDeviceNode
1464 CHAR16
*RemoteIPStr
;
1465 CHAR16
*ProtocolStr
;
1468 IPv4_DEVICE_PATH
*IPv4
;
1470 RemoteIPStr
= GetNextParamStr (&TextDeviceNode
);
1471 ProtocolStr
= GetNextParamStr (&TextDeviceNode
);
1472 TypeStr
= GetNextParamStr (&TextDeviceNode
);
1473 LocalIPStr
= GetNextParamStr (&TextDeviceNode
);
1474 IPv4
= (IPv4_DEVICE_PATH
*) CreateDeviceNode (
1475 MESSAGING_DEVICE_PATH
,
1477 sizeof (IPv4_DEVICE_PATH
)
1480 StrToIPv4Addr (&RemoteIPStr
, &IPv4
->RemoteIpAddress
);
1481 IPv4
->Protocol
= (UINT16
) ((StrCmp (ProtocolStr
, L
"UDP") == 0) ? 0 : 1);
1482 if (StrCmp (TypeStr
, L
"Static") == 0) {
1483 IPv4
->StaticIpAddress
= TRUE
;
1485 IPv4
->StaticIpAddress
= FALSE
;
1488 StrToIPv4Addr (&LocalIPStr
, &IPv4
->LocalIpAddress
);
1490 IPv4
->LocalPort
= 0;
1491 IPv4
->RemotePort
= 0;
1493 return (EFI_DEVICE_PATH_PROTOCOL
*) IPv4
;
1497 EFI_DEVICE_PATH_PROTOCOL
*
1498 DevPathFromTextIPv6 (
1499 IN CHAR16
*TextDeviceNode
1502 CHAR16
*RemoteIPStr
;
1503 CHAR16
*ProtocolStr
;
1506 IPv6_DEVICE_PATH
*IPv6
;
1508 RemoteIPStr
= GetNextParamStr (&TextDeviceNode
);
1509 ProtocolStr
= GetNextParamStr (&TextDeviceNode
);
1510 TypeStr
= GetNextParamStr (&TextDeviceNode
);
1511 LocalIPStr
= GetNextParamStr (&TextDeviceNode
);
1512 IPv6
= (IPv6_DEVICE_PATH
*) CreateDeviceNode (
1513 MESSAGING_DEVICE_PATH
,
1515 sizeof (IPv6_DEVICE_PATH
)
1518 StrToIPv6Addr (&RemoteIPStr
, &IPv6
->RemoteIpAddress
);
1519 IPv6
->Protocol
= (UINT16
) ((StrCmp (ProtocolStr
, L
"UDP") == 0) ? 0 : 1);
1520 if (StrCmp (TypeStr
, L
"Static") == 0) {
1521 IPv6
->StaticIpAddress
= TRUE
;
1523 IPv6
->StaticIpAddress
= FALSE
;
1526 StrToIPv6Addr (&LocalIPStr
, &IPv6
->LocalIpAddress
);
1528 IPv6
->LocalPort
= 0;
1529 IPv6
->RemotePort
= 0;
1531 return (EFI_DEVICE_PATH_PROTOCOL
*) IPv6
;
1535 EFI_DEVICE_PATH_PROTOCOL
*
1536 DevPathFromTextUart (
1537 IN CHAR16
*TextDeviceNode
1541 CHAR16
*DataBitsStr
;
1543 CHAR16
*StopBitsStr
;
1544 UART_DEVICE_PATH
*Uart
;
1546 BaudStr
= GetNextParamStr (&TextDeviceNode
);
1547 DataBitsStr
= GetNextParamStr (&TextDeviceNode
);
1548 ParityStr
= GetNextParamStr (&TextDeviceNode
);
1549 StopBitsStr
= GetNextParamStr (&TextDeviceNode
);
1550 Uart
= (UART_DEVICE_PATH
*) CreateDeviceNode (
1551 MESSAGING_DEVICE_PATH
,
1553 sizeof (UART_DEVICE_PATH
)
1556 Uart
->BaudRate
= (StrCmp (BaudStr
, L
"DEFAULT") == 0) ? 115200 : Atoi (BaudStr
);
1557 Uart
->DataBits
= (UINT8
) ((StrCmp (DataBitsStr
, L
"DEFAULT") == 0) ? 8 : Atoi (DataBitsStr
));
1558 switch (*ParityStr
) {
1583 Uart
->Parity
= 0xff;
1586 if (StrCmp (StopBitsStr
, L
"D") == 0) {
1587 Uart
->StopBits
= (UINT8
) 0;
1588 } else if (StrCmp (StopBitsStr
, L
"1") == 0) {
1589 Uart
->StopBits
= (UINT8
) 1;
1590 } else if (StrCmp (StopBitsStr
, L
"1.5") == 0) {
1591 Uart
->StopBits
= (UINT8
) 2;
1592 } else if (StrCmp (StopBitsStr
, L
"2") == 0) {
1593 Uart
->StopBits
= (UINT8
) 3;
1595 Uart
->StopBits
= 0xff;
1598 return (EFI_DEVICE_PATH_PROTOCOL
*) Uart
;
1602 EFI_DEVICE_PATH_PROTOCOL
*
1603 ConvertFromTextUsbClass (
1604 IN CHAR16
*TextDeviceNode
,
1605 IN USB_CLASS_TEXT
*UsbClassText
1611 CHAR16
*SubClassStr
;
1612 CHAR16
*ProtocolStr
;
1613 USB_CLASS_DEVICE_PATH
*UsbClass
;
1615 UsbClass
= (USB_CLASS_DEVICE_PATH
*) CreateDeviceNode (
1616 MESSAGING_DEVICE_PATH
,
1618 sizeof (USB_CLASS_DEVICE_PATH
)
1621 VIDStr
= GetNextParamStr (&TextDeviceNode
);
1622 PIDStr
= GetNextParamStr (&TextDeviceNode
);
1623 if (UsbClassText
->ClassExist
) {
1624 ClassStr
= GetNextParamStr (&TextDeviceNode
);
1625 UsbClass
->DeviceClass
= (UINT8
) Xtoi (ClassStr
);
1627 UsbClass
->DeviceClass
= UsbClassText
->Class
;
1629 if (UsbClassText
->SubClassExist
) {
1630 SubClassStr
= GetNextParamStr (&TextDeviceNode
);
1631 UsbClass
->DeviceSubClass
= (UINT8
) Xtoi (SubClassStr
);
1633 UsbClass
->DeviceSubClass
= UsbClassText
->SubClass
;
1636 ProtocolStr
= GetNextParamStr (&TextDeviceNode
);
1638 UsbClass
->VendorId
= (UINT16
) Xtoi (VIDStr
);
1639 UsbClass
->ProductId
= (UINT16
) Xtoi (PIDStr
);
1640 UsbClass
->DeviceProtocol
= (UINT8
) Xtoi (ProtocolStr
);
1642 return (EFI_DEVICE_PATH_PROTOCOL
*) UsbClass
;
1647 EFI_DEVICE_PATH_PROTOCOL
*
1648 DevPathFromTextUsbClass (
1649 IN CHAR16
*TextDeviceNode
1652 USB_CLASS_TEXT UsbClassText
;
1654 UsbClassText
.ClassExist
= TRUE
;
1655 UsbClassText
.SubClassExist
= TRUE
;
1657 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1661 EFI_DEVICE_PATH_PROTOCOL
*
1662 DevPathFromTextUsbAudio (
1663 IN CHAR16
*TextDeviceNode
1666 USB_CLASS_TEXT UsbClassText
;
1668 UsbClassText
.ClassExist
= FALSE
;
1669 UsbClassText
.Class
= USB_CLASS_AUDIO
;
1670 UsbClassText
.SubClassExist
= TRUE
;
1672 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1676 EFI_DEVICE_PATH_PROTOCOL
*
1677 DevPathFromTextUsbCDCControl (
1678 IN CHAR16
*TextDeviceNode
1681 USB_CLASS_TEXT UsbClassText
;
1683 UsbClassText
.ClassExist
= FALSE
;
1684 UsbClassText
.Class
= USB_CLASS_CDCCONTROL
;
1685 UsbClassText
.SubClassExist
= TRUE
;
1687 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1691 EFI_DEVICE_PATH_PROTOCOL
*
1692 DevPathFromTextUsbHID (
1693 IN CHAR16
*TextDeviceNode
1696 USB_CLASS_TEXT UsbClassText
;
1698 UsbClassText
.ClassExist
= FALSE
;
1699 UsbClassText
.Class
= USB_CLASS_HID
;
1700 UsbClassText
.SubClassExist
= TRUE
;
1702 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1706 EFI_DEVICE_PATH_PROTOCOL
*
1707 DevPathFromTextUsbImage (
1708 IN CHAR16
*TextDeviceNode
1711 USB_CLASS_TEXT UsbClassText
;
1713 UsbClassText
.ClassExist
= FALSE
;
1714 UsbClassText
.Class
= USB_CLASS_IMAGE
;
1715 UsbClassText
.SubClassExist
= TRUE
;
1717 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1721 EFI_DEVICE_PATH_PROTOCOL
*
1722 DevPathFromTextUsbPrinter (
1723 IN CHAR16
*TextDeviceNode
1726 USB_CLASS_TEXT UsbClassText
;
1728 UsbClassText
.ClassExist
= FALSE
;
1729 UsbClassText
.Class
= USB_CLASS_PRINTER
;
1730 UsbClassText
.SubClassExist
= TRUE
;
1732 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1736 EFI_DEVICE_PATH_PROTOCOL
*
1737 DevPathFromTextUsbMassStorage (
1738 IN CHAR16
*TextDeviceNode
1741 USB_CLASS_TEXT UsbClassText
;
1743 UsbClassText
.ClassExist
= FALSE
;
1744 UsbClassText
.Class
= USB_CLASS_MASS_STORAGE
;
1745 UsbClassText
.SubClassExist
= TRUE
;
1747 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1751 EFI_DEVICE_PATH_PROTOCOL
*
1752 DevPathFromTextUsbHub (
1753 IN CHAR16
*TextDeviceNode
1756 USB_CLASS_TEXT UsbClassText
;
1758 UsbClassText
.ClassExist
= FALSE
;
1759 UsbClassText
.Class
= USB_CLASS_HUB
;
1760 UsbClassText
.SubClassExist
= TRUE
;
1762 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1766 EFI_DEVICE_PATH_PROTOCOL
*
1767 DevPathFromTextUsbCDCData (
1768 IN CHAR16
*TextDeviceNode
1771 USB_CLASS_TEXT UsbClassText
;
1773 UsbClassText
.ClassExist
= FALSE
;
1774 UsbClassText
.Class
= USB_CLASS_CDCDATA
;
1775 UsbClassText
.SubClassExist
= TRUE
;
1777 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1781 EFI_DEVICE_PATH_PROTOCOL
*
1782 DevPathFromTextUsbSmartCard (
1783 IN CHAR16
*TextDeviceNode
1786 USB_CLASS_TEXT UsbClassText
;
1788 UsbClassText
.ClassExist
= FALSE
;
1789 UsbClassText
.Class
= USB_CLASS_SMART_CARD
;
1790 UsbClassText
.SubClassExist
= TRUE
;
1792 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1796 EFI_DEVICE_PATH_PROTOCOL
*
1797 DevPathFromTextUsbVideo (
1798 IN CHAR16
*TextDeviceNode
1801 USB_CLASS_TEXT UsbClassText
;
1803 UsbClassText
.ClassExist
= FALSE
;
1804 UsbClassText
.Class
= USB_CLASS_VIDEO
;
1805 UsbClassText
.SubClassExist
= TRUE
;
1807 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1811 EFI_DEVICE_PATH_PROTOCOL
*
1812 DevPathFromTextUsbDiagnostic (
1813 IN CHAR16
*TextDeviceNode
1816 USB_CLASS_TEXT UsbClassText
;
1818 UsbClassText
.ClassExist
= FALSE
;
1819 UsbClassText
.Class
= USB_CLASS_DIAGNOSTIC
;
1820 UsbClassText
.SubClassExist
= TRUE
;
1822 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1826 EFI_DEVICE_PATH_PROTOCOL
*
1827 DevPathFromTextUsbWireless (
1828 IN CHAR16
*TextDeviceNode
1831 USB_CLASS_TEXT UsbClassText
;
1833 UsbClassText
.ClassExist
= FALSE
;
1834 UsbClassText
.Class
= USB_CLASS_WIRELESS
;
1835 UsbClassText
.SubClassExist
= TRUE
;
1837 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1841 EFI_DEVICE_PATH_PROTOCOL
*
1842 DevPathFromTextUsbDeviceFirmwareUpdate (
1843 IN CHAR16
*TextDeviceNode
1846 USB_CLASS_TEXT UsbClassText
;
1848 UsbClassText
.ClassExist
= FALSE
;
1849 UsbClassText
.Class
= USB_CLASS_RESERVE
;
1850 UsbClassText
.SubClassExist
= FALSE
;
1851 UsbClassText
.SubClass
= USB_SUBCLASS_FW_UPDATE
;
1853 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1857 EFI_DEVICE_PATH_PROTOCOL
*
1858 DevPathFromTextUsbIrdaBridge (
1859 IN CHAR16
*TextDeviceNode
1862 USB_CLASS_TEXT UsbClassText
;
1864 UsbClassText
.ClassExist
= FALSE
;
1865 UsbClassText
.Class
= USB_CLASS_RESERVE
;
1866 UsbClassText
.SubClassExist
= FALSE
;
1867 UsbClassText
.SubClass
= USB_SUBCLASS_IRDA_BRIDGE
;
1869 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1873 EFI_DEVICE_PATH_PROTOCOL
*
1874 DevPathFromTextUsbTestAndMeasurement (
1875 IN CHAR16
*TextDeviceNode
1878 USB_CLASS_TEXT UsbClassText
;
1880 UsbClassText
.ClassExist
= FALSE
;
1881 UsbClassText
.Class
= USB_CLASS_RESERVE
;
1882 UsbClassText
.SubClassExist
= FALSE
;
1883 UsbClassText
.SubClass
= USB_SUBCLASS_TEST
;
1885 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1889 EFI_DEVICE_PATH_PROTOCOL
*
1890 DevPathFromTextUsbWwid (
1891 IN CHAR16
*TextDeviceNode
1896 CHAR16
*InterfaceNumStr
;
1897 USB_WWID_DEVICE_PATH
*UsbWwid
;
1899 VIDStr
= GetNextParamStr (&TextDeviceNode
);
1900 PIDStr
= GetNextParamStr (&TextDeviceNode
);
1901 InterfaceNumStr
= GetNextParamStr (&TextDeviceNode
);
1902 UsbWwid
= (USB_WWID_DEVICE_PATH
*) CreateDeviceNode (
1903 MESSAGING_DEVICE_PATH
,
1905 sizeof (USB_WWID_DEVICE_PATH
)
1908 UsbWwid
->VendorId
= (UINT16
) Xtoi (VIDStr
);
1909 UsbWwid
->ProductId
= (UINT16
) Xtoi (PIDStr
);
1910 UsbWwid
->InterfaceNumber
= (UINT16
) Xtoi (InterfaceNumStr
);
1912 return (EFI_DEVICE_PATH_PROTOCOL
*) UsbWwid
;
1916 EFI_DEVICE_PATH_PROTOCOL
*
1917 DevPathFromTextUnit (
1918 IN CHAR16
*TextDeviceNode
1922 DEVICE_LOGICAL_UNIT_DEVICE_PATH
*LogicalUnit
;
1924 LunStr
= GetNextParamStr (&TextDeviceNode
);
1925 LogicalUnit
= (DEVICE_LOGICAL_UNIT_DEVICE_PATH
*) CreateDeviceNode (
1926 MESSAGING_DEVICE_PATH
,
1927 MSG_DEVICE_LOGICAL_UNIT_DP
,
1928 sizeof (DEVICE_LOGICAL_UNIT_DEVICE_PATH
)
1931 LogicalUnit
->Lun
= (UINT8
) Xtoi (LunStr
);
1933 return (EFI_DEVICE_PATH_PROTOCOL
*) LogicalUnit
;
1937 EFI_DEVICE_PATH_PROTOCOL
*
1938 DevPathFromTextiSCSI (
1939 IN CHAR16
*TextDeviceNode
1944 CHAR16
*PortalGroupStr
;
1946 CHAR16
*HeaderDigestStr
;
1947 CHAR16
*DataDigestStr
;
1948 CHAR16
*AuthenticationStr
;
1949 CHAR16
*ProtocolStr
;
1950 ISCSI_DEVICE_PATH_WITH_NAME
*iSCSI
;
1952 NameStr
= GetNextParamStr (&TextDeviceNode
);
1953 PortalGroupStr
= GetNextParamStr (&TextDeviceNode
);
1954 LunStr
= GetNextParamStr (&TextDeviceNode
);
1955 HeaderDigestStr
= GetNextParamStr (&TextDeviceNode
);
1956 DataDigestStr
= GetNextParamStr (&TextDeviceNode
);
1957 AuthenticationStr
= GetNextParamStr (&TextDeviceNode
);
1958 ProtocolStr
= GetNextParamStr (&TextDeviceNode
);
1959 iSCSI
= (ISCSI_DEVICE_PATH_WITH_NAME
*) CreateDeviceNode (
1960 MESSAGING_DEVICE_PATH
,
1962 sizeof (ISCSI_DEVICE_PATH_WITH_NAME
) + (UINT16
) (StrLen (NameStr
) * 2)
1965 StrCpy (iSCSI
->iSCSITargetName
, NameStr
);
1966 iSCSI
->TargetPortalGroupTag
= (UINT16
) Xtoi (PortalGroupStr
);
1967 Xtoi64 (LunStr
, &iSCSI
->Lun
);
1970 if (StrCmp (HeaderDigestStr
, L
"CRC32C") == 0) {
1974 if (StrCmp (DataDigestStr
, L
"CRC32C") == 0) {
1978 if (StrCmp (AuthenticationStr
, L
"None") == 0) {
1982 if (StrCmp (AuthenticationStr
, L
"CHAP_UNI") == 0) {
1986 iSCSI
->LoginOption
= (UINT16
) Options
;
1988 iSCSI
->NetworkProtocol
= (UINT16
) StrCmp (ProtocolStr
, L
"TCP");
1989 iSCSI
->Reserved
= (UINT16
) 0;
1991 return (EFI_DEVICE_PATH_PROTOCOL
*) iSCSI
;
1995 EFI_DEVICE_PATH_PROTOCOL
*
1997 IN CHAR16
*TextDeviceNode
2000 CHAR16
*PartitionStr
;
2002 CHAR16
*SignatureStr
;
2006 EFI_GUID SignatureGuid
;
2007 HARDDRIVE_DEVICE_PATH
*Hd
;
2009 PartitionStr
= GetNextParamStr (&TextDeviceNode
);
2010 TypeStr
= GetNextParamStr (&TextDeviceNode
);
2011 SignatureStr
= GetNextParamStr (&TextDeviceNode
);
2012 StartStr
= GetNextParamStr (&TextDeviceNode
);
2013 SizeStr
= GetNextParamStr (&TextDeviceNode
);
2014 Hd
= (HARDDRIVE_DEVICE_PATH
*) CreateDeviceNode (
2017 sizeof (HARDDRIVE_DEVICE_PATH
)
2020 Hd
->PartitionNumber
= (UINT32
) Atoi (PartitionStr
);
2022 ZeroMem (Hd
->Signature
, 16);
2023 Hd
->MBRType
= (UINT8
) 0;
2025 if (StrCmp (TypeStr
, L
"None") == 0) {
2026 Hd
->SignatureType
= (UINT8
) 0;
2027 } else if (StrCmp (TypeStr
, L
"MBR") == 0) {
2028 Hd
->SignatureType
= SIGNATURE_TYPE_MBR
;
2031 Signature32
= (UINT32
) Xtoi (SignatureStr
);
2032 CopyMem (Hd
->Signature
, &Signature32
, sizeof (UINT32
));
2033 } else if (StrCmp (TypeStr
, L
"GUID") == 0) {
2034 Hd
->SignatureType
= SIGNATURE_TYPE_GUID
;
2037 StrToGuid (SignatureStr
, &SignatureGuid
);
2038 CopyMem (Hd
->Signature
, &SignatureGuid
, sizeof (EFI_GUID
));
2040 Hd
->SignatureType
= 0xff;
2044 Xtoi64 (StartStr
, &Hd
->PartitionStart
);
2045 Xtoi64 (SizeStr
, &Hd
->PartitionSize
);
2047 return (EFI_DEVICE_PATH_PROTOCOL
*) Hd
;
2051 EFI_DEVICE_PATH_PROTOCOL
*
2052 DevPathFromTextCDROM (
2053 IN CHAR16
*TextDeviceNode
2059 CDROM_DEVICE_PATH
*CDROM
;
2061 EntryStr
= GetNextParamStr (&TextDeviceNode
);
2062 StartStr
= GetNextParamStr (&TextDeviceNode
);
2063 SizeStr
= GetNextParamStr (&TextDeviceNode
);
2064 CDROM
= (CDROM_DEVICE_PATH
*) CreateDeviceNode (
2067 sizeof (CDROM_DEVICE_PATH
)
2070 CDROM
->BootEntry
= (UINT32
) Xtoi (EntryStr
);
2071 Xtoi64 (StartStr
, &CDROM
->PartitionStart
);
2072 Xtoi64 (SizeStr
, &CDROM
->PartitionSize
);
2074 return (EFI_DEVICE_PATH_PROTOCOL
*) CDROM
;
2078 EFI_DEVICE_PATH_PROTOCOL
*
2079 DevPathFromTextVenMEDIA (
2080 IN CHAR16
*TextDeviceNode
2083 return ConvertFromTextVendor (
2091 EFI_DEVICE_PATH_PROTOCOL
*
2092 DevPathFromTextFilePath (
2093 IN CHAR16
*TextDeviceNode
2096 FILEPATH_DEVICE_PATH
*File
;
2098 File
= (FILEPATH_DEVICE_PATH
*) CreateDeviceNode (
2101 sizeof (FILEPATH_DEVICE_PATH
) + (UINT16
) (StrLen (TextDeviceNode
) * 2)
2104 StrCpy (File
->PathName
, TextDeviceNode
);
2106 return (EFI_DEVICE_PATH_PROTOCOL
*) File
;
2110 EFI_DEVICE_PATH_PROTOCOL
*
2111 DevPathFromTextMedia (
2112 IN CHAR16
*TextDeviceNode
2116 MEDIA_PROTOCOL_DEVICE_PATH
*Media
;
2118 GuidStr
= GetNextParamStr (&TextDeviceNode
);
2119 Media
= (MEDIA_PROTOCOL_DEVICE_PATH
*) CreateDeviceNode (
2122 sizeof (MEDIA_PROTOCOL_DEVICE_PATH
)
2125 StrToGuid (GuidStr
, &Media
->Protocol
);
2127 return (EFI_DEVICE_PATH_PROTOCOL
*) Media
;
2131 EFI_DEVICE_PATH_PROTOCOL
*
2132 DevPathFromTextBBS (
2133 IN CHAR16
*TextDeviceNode
2140 BBS_BBS_DEVICE_PATH
*Bbs
;
2142 TypeStr
= GetNextParamStr (&TextDeviceNode
);
2143 IdStr
= GetNextParamStr (&TextDeviceNode
);
2144 FlagsStr
= GetNextParamStr (&TextDeviceNode
);
2145 Bbs
= (BBS_BBS_DEVICE_PATH
*) CreateDeviceNode (
2148 sizeof (BBS_BBS_DEVICE_PATH
) + (UINT16
) (StrLen (IdStr
))
2151 if (StrCmp (TypeStr
, L
"Floppy") == 0) {
2152 Bbs
->DeviceType
= BBS_TYPE_FLOPPY
;
2153 } else if (StrCmp (TypeStr
, L
"HD") == 0) {
2154 Bbs
->DeviceType
= BBS_TYPE_HARDDRIVE
;
2155 } else if (StrCmp (TypeStr
, L
"CDROM") == 0) {
2156 Bbs
->DeviceType
= BBS_TYPE_CDROM
;
2157 } else if (StrCmp (TypeStr
, L
"PCMCIA") == 0) {
2158 Bbs
->DeviceType
= BBS_TYPE_PCMCIA
;
2159 } else if (StrCmp (TypeStr
, L
"USB") == 0) {
2160 Bbs
->DeviceType
= BBS_TYPE_USB
;
2161 } else if (StrCmp (TypeStr
, L
"Network") == 0) {
2162 Bbs
->DeviceType
= BBS_TYPE_EMBEDDED_NETWORK
;
2164 Bbs
->DeviceType
= BBS_TYPE_UNKNOWN
;
2167 AsciiStr
= (UINT8
*) Bbs
->String
;
2168 StrToAscii (IdStr
, (CHAR8
**) &AsciiStr
);
2170 Bbs
->StatusFlag
= (UINT16
) Xtoi (FlagsStr
);
2172 return (EFI_DEVICE_PATH_PROTOCOL
*) Bbs
;
2175 GLOBAL_REMOVE_IF_UNREFERENCED DEVICE_PATH_FROM_TEXT_TABLE DevPathFromTextTable
[] = {
2176 {L
"Pci", DevPathFromTextPci
},
2177 {L
"PcCard", DevPathFromTextPcCard
},
2178 {L
"MemoryMapped", DevPathFromTextMemoryMapped
},
2179 {L
"VenHw", DevPathFromTextVenHw
},
2180 {L
"Ctrl", DevPathFromTextCtrl
},
2181 {L
"Acpi", DevPathFromTextAcpi
},
2182 {L
"PciRoot", DevPathFromTextPciRoot
},
2183 {L
"Floppy", DevPathFromTextFloppy
},
2184 {L
"Keyboard", DevPathFromTextKeyboard
},
2185 {L
"Serial", DevPathFromTextSerial
},
2186 {L
"ParallelPort", DevPathFromTextParallelPort
},
2187 {L
"AcpiEx", DevPathFromTextAcpiEx
},
2188 {L
"AcpiExp", DevPathFromTextAcpiExp
},
2189 {L
"Ata", DevPathFromTextAta
},
2190 {L
"Scsi", DevPathFromTextScsi
},
2191 {L
"Fibre", DevPathFromTextFibre
},
2192 {L
"I1394", DevPathFromText1394
},
2193 {L
"USB", DevPathFromTextUsb
},
2194 {L
"I2O", DevPathFromTextI2O
},
2195 {L
"Infiniband", DevPathFromTextInfiniband
},
2196 {L
"VenMsg", DevPathFromTextVenMsg
},
2197 {L
"VenPcAnsi", DevPathFromTextVenPcAnsi
},
2198 {L
"VenVt100", DevPathFromTextVenVt100
},
2199 {L
"VenVt100Plus", DevPathFromTextVenVt100Plus
},
2200 {L
"VenUtf8", DevPathFromTextVenUtf8
},
2201 {L
"UartFlowCtrl", DevPathFromTextUartFlowCtrl
},
2202 {L
"SAS", DevPathFromTextSAS
},
2203 {L
"DebugPort", DevPathFromTextDebugPort
},
2204 {L
"MAC", DevPathFromTextMAC
},
2205 {L
"IPv4", DevPathFromTextIPv4
},
2206 {L
"IPv6", DevPathFromTextIPv6
},
2207 {L
"Uart", DevPathFromTextUart
},
2208 {L
"UsbClass", DevPathFromTextUsbClass
},
2209 {L
"UsbAudio", DevPathFromTextUsbAudio
},
2210 {L
"UsbCDCControl", DevPathFromTextUsbCDCControl
},
2211 {L
"UsbHID", DevPathFromTextUsbHID
},
2212 {L
"UsbImage", DevPathFromTextUsbImage
},
2213 {L
"UsbPrinter", DevPathFromTextUsbPrinter
},
2214 {L
"UsbMassStorage", DevPathFromTextUsbMassStorage
},
2215 {L
"UsbHub", DevPathFromTextUsbHub
},
2216 {L
"UsbCDCData", DevPathFromTextUsbCDCData
},
2217 {L
"UsbSmartCard", DevPathFromTextUsbSmartCard
},
2218 {L
"UsbVideo", DevPathFromTextUsbVideo
},
2219 {L
"UsbDiagnostic", DevPathFromTextUsbDiagnostic
},
2220 {L
"UsbWireless", DevPathFromTextUsbWireless
},
2221 {L
"UsbDeviceFirmwareUpdate", DevPathFromTextUsbDeviceFirmwareUpdate
},
2222 {L
"UsbIrdaBridge", DevPathFromTextUsbIrdaBridge
},
2223 {L
"UsbTestAndMeasurement", DevPathFromTextUsbTestAndMeasurement
},
2224 {L
"UsbWwid", DevPathFromTextUsbWwid
},
2225 {L
"Unit", DevPathFromTextUnit
},
2226 {L
"iSCSI", DevPathFromTextiSCSI
},
2227 {L
"HD", DevPathFromTextHD
},
2228 {L
"CDROM", DevPathFromTextCDROM
},
2229 {L
"VenMEDIA", DevPathFromTextVenMEDIA
},
2230 {L
"Media", DevPathFromTextMedia
},
2231 {L
"BBS", DevPathFromTextBBS
},
2235 EFI_DEVICE_PATH_PROTOCOL
*
2236 ConvertTextToDeviceNode (
2237 IN CONST CHAR16
*TextDeviceNode
2241 Routine Description:
2242 Convert text to the binary representation of a device node.
2245 TextDeviceNode - TextDeviceNode points to the text representation of a device
2246 node. Conversion starts with the first character and continues
2247 until the first non-device node character.
2250 A pointer - Pointer to the EFI device node.
2251 NULL - If TextDeviceNode is NULL or there was insufficient memory or text unsupported.
2255 EFI_DEVICE_PATH_PROTOCOL
* (*DumpNode
) (CHAR16
*);
2257 EFI_DEVICE_PATH_PROTOCOL
*DeviceNode
;
2258 CHAR16
*DeviceNodeStr
;
2261 if ((TextDeviceNode
== NULL
) || (IS_NULL (*TextDeviceNode
))) {
2267 DeviceNodeStr
= StrDuplicate (TextDeviceNode
);
2269 for (Index
= 0; DevPathFromTextTable
[Index
].Function
; Index
++) {
2270 ParamStr
= GetParamByNodeName (DeviceNodeStr
, DevPathFromTextTable
[Index
].DevicePathNodeText
);
2271 if (ParamStr
!= NULL
) {
2272 DumpNode
= DevPathFromTextTable
[Index
].Function
;
2277 if (DumpNode
== NULL
) {
2281 DumpNode
= DevPathFromTextFilePath
;
2282 DeviceNode
= DumpNode (DeviceNodeStr
);
2284 DeviceNode
= DumpNode (ParamStr
);
2285 FreePool (ParamStr
);
2288 FreePool (DeviceNodeStr
);
2293 EFI_DEVICE_PATH_PROTOCOL
*
2294 ConvertTextToDevicePath (
2295 IN CONST CHAR16
*TextDevicePath
2299 Routine Description:
2300 Convert text to the binary representation of a device path.
2303 TextDevicePath - TextDevicePath points to the text representation of a device
2304 path. Conversion starts with the first character and continues
2305 until the first non-device node character.
2308 A pointer - Pointer to the allocated device path.
2309 NULL - If TextDeviceNode is NULL or there was insufficient memory.
2313 EFI_DEVICE_PATH_PROTOCOL
* (*DumpNode
) (CHAR16
*);
2315 EFI_DEVICE_PATH_PROTOCOL
*DeviceNode
;
2317 EFI_DEVICE_PATH_PROTOCOL
*NewDevicePath
;
2318 CHAR16
*DevicePathStr
;
2320 CHAR16
*DeviceNodeStr
;
2321 UINT8 IsInstanceEnd
;
2322 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
2324 if ((TextDevicePath
== NULL
) || (IS_NULL (*TextDevicePath
))) {
2328 DevicePath
= (EFI_DEVICE_PATH_PROTOCOL
*) AllocatePool (END_DEVICE_PATH_LENGTH
);
2329 SetDevicePathEndNode (DevicePath
);
2332 DeviceNodeStr
= NULL
;
2333 DevicePathStr
= StrDuplicate (TextDevicePath
);
2335 Str
= DevicePathStr
;
2336 while ((DeviceNodeStr
= GetNextDeviceNodeStr (&Str
, &IsInstanceEnd
)) != NULL
) {
2338 for (Index
= 0; DevPathFromTextTable
[Index
].Function
; Index
++) {
2339 ParamStr
= GetParamByNodeName (DeviceNodeStr
, DevPathFromTextTable
[Index
].DevicePathNodeText
);
2340 if (ParamStr
!= NULL
) {
2341 DumpNode
= DevPathFromTextTable
[Index
].Function
;
2346 if (DumpNode
== NULL
) {
2350 DumpNode
= DevPathFromTextFilePath
;
2351 DeviceNode
= DumpNode (DeviceNodeStr
);
2353 DeviceNode
= DumpNode (ParamStr
);
2354 FreePool (ParamStr
);
2357 NewDevicePath
= AppendDeviceNodeProtocolInterface (DevicePath
, DeviceNode
);
2358 FreePool (DevicePath
);
2359 FreePool (DeviceNode
);
2360 DevicePath
= NewDevicePath
;
2362 if (IsInstanceEnd
) {
2363 DeviceNode
= (EFI_DEVICE_PATH_PROTOCOL
*) AllocatePool (END_DEVICE_PATH_LENGTH
);
2364 SetDevicePathInstanceEndNode (DeviceNode
);
2366 NewDevicePath
= AppendDeviceNodeProtocolInterface (DevicePath
, DeviceNode
);
2367 FreePool (DevicePath
);
2368 FreePool (DeviceNode
);
2369 DevicePath
= NewDevicePath
;
2373 FreePool (DevicePathStr
);