2 DevicePathFromText protocol as defined in the UEFI 2.0 specification.
4 Copyright (c) 2006 - 2008, Intel Corporation. <BR>
5 All rights reserved. This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
15 #include "DevicePath.h"
22 @param Src Source string.
24 @return The duplicated string.
32 return AllocateCopyPool (StrSize (Src
), Src
);
37 Get parameter in a pair of parentheses follow the given node name.
38 For example, given the "Pci(0,1)" and NodeName "Pci", it returns "0,1".
40 @param Str Device Path Text.
41 @param NodeName Name of the node.
43 @return Parameter text for the node.
55 UINTN ParameterLength
;
58 // Check whether the node name matchs
60 NodeNameLength
= StrLen (NodeName
);
61 if (CompareMem (Str
, NodeName
, NodeNameLength
* sizeof (CHAR16
)) != 0) {
65 ParamStr
= Str
+ NodeNameLength
;
66 if (!IS_LEFT_PARENTH (*ParamStr
)) {
71 // Skip the found '(' and find first occurrence of ')'
75 StrPointer
= ParamStr
;
76 while (!IS_NULL (*StrPointer
)) {
77 if (IS_RIGHT_PARENTH (*StrPointer
)) {
83 if (IS_NULL (*StrPointer
)) {
90 ParamStr
= AllocateCopyPool ((ParameterLength
+ 1) * sizeof (CHAR16
), ParamStr
);
91 if (ParamStr
== NULL
) {
95 // Terminate the parameter string
97 ParamStr
[ParameterLength
] = L
'\0';
103 Gets current sub-string from a string list, before return
104 the list header is moved to next sub-string. The sub-string is separated
105 by the specified character. For example, the separator is ',', the string
106 list is "2,0,3", it returns "2", the remain list move to "0,3"
108 @param List A string list separated by the specified separator
109 @param Separator The separator character
111 @return A pointer to the current sub-string
116 IN OUT CHAR16
**List
,
126 if (IS_NULL (*Str
)) {
131 // Find first occurrence of the separator
133 while (!IS_NULL (*Str
)) {
134 if (*Str
== Separator
) {
140 if (*Str
== Separator
) {
142 // Find a sub-string, terminate it
149 // Move to next sub-string
157 Gets the next parameter string from the list.
159 @param List A string list separated by the specified separator
161 @return A pointer to the current sub-string
170 // The separator is comma
172 return SplitStr (List
, L
',');
176 Get one device node from entire device path text.
178 @param DevicePath On input, the current Device Path node; on output, the next device path node
179 @param IsInstanceEnd This node is the end of a device path instance
181 @return A device node text or NULL if no more device node available
185 GetNextDeviceNodeStr (
186 IN OUT CHAR16
**DevicePath
,
187 OUT BOOLEAN
*IsInstanceEnd
192 UINTN ParenthesesStack
;
195 if (IS_NULL (*Str
)) {
200 // Skip the leading '/', '(', ')' and ','
202 while (!IS_NULL (*Str
)) {
203 if (!IS_SLASH (*Str
) &&
205 !IS_LEFT_PARENTH (*Str
) &&
206 !IS_RIGHT_PARENTH (*Str
)) {
215 // Scan for the separator of this device node, '/' or ','
217 ParenthesesStack
= 0;
218 while (!IS_NULL (*Str
)) {
219 if ((IS_COMMA (*Str
) || IS_SLASH (*Str
)) && (ParenthesesStack
== 0)) {
223 if (IS_LEFT_PARENTH (*Str
)) {
225 } else if (IS_RIGHT_PARENTH (*Str
)) {
232 if (ParenthesesStack
!= 0) {
234 // The '(' doesn't pair with ')', invalid device path text
239 if (IS_COMMA (*Str
)) {
240 *IsInstanceEnd
= TRUE
;
244 *IsInstanceEnd
= FALSE
;
245 if (!IS_NULL (*Str
)) {
258 Skip the leading white space and '0x' or '0X' of a integer string
260 @param Str The integer string
261 @param IsHex TRUE: Hex string, FALSE: Decimal string
263 @return The trimmed Hex string.
275 // skip preceeding white space
277 while ((*Str
!= 0) && *Str
== ' ') {
281 // skip preceeding zeros
283 while ((*Str
!= 0) && *Str
== '0') {
287 // skip preceeding character 'x' or 'X'
289 if ((*Str
!= 0) && (*Str
== 'x' || *Str
== 'X')) {
299 Convert hex string to uint.
301 @param Str The hex string
303 @return A UINTN value represented by Str
311 return StrHexToUintn (Str
);
316 Convert hex string to 64 bit data.
318 @param Str The hex string
319 @param Data A pointer to the UINT64 value represented by Str
328 *Data
= StrHexToUint64 (Str
);
333 Convert decimal string to uint.
335 @param Str The decimal string
337 @return A UINTN value represented by Str
350 ASSERT (Str
!= NULL
);
352 High
= (UINTN
) -1 / 10;
353 Low
= (UINTN
) -1 % 10;
355 // skip preceeding white space
357 while ((*Str
!= 0) && *Str
== ' ') {
366 if (Char
>= '0' && Char
<= '9') {
367 if ((Rvalue
> High
|| Rvalue
== High
) && (Char
- '0' > (INTN
) Low
)) {
371 Rvalue
= (Rvalue
* 10) + Char
- '0';
384 Convert decimal string to uint.
386 @param Str The decimal string
387 @param Data A pointer to the UINT64 value represented by Str
401 ASSERT (Str
!= NULL
);
402 ASSERT (Data
!= NULL
);
405 // skip preceeding white space
407 while ((*Str
!= 0) && *Str
== ' ') {
416 if (Char
>= '0' && Char
<= '9') {
417 High
= LShiftU64 (Rvalue
, 3);
418 Low
= LShiftU64 (Rvalue
, 1);
419 Rvalue
= High
+ Low
+ Char
- '0';
432 Convert integer string to uint.
434 @param Str The integer string. If leading with "0x" or "0X", it's heximal.
436 @return A UINTN value represented by Str
446 Str
= TrimHexStr (Str
, &IsHex
);
457 Convert integer string to 64 bit data.
459 @param Str The integer string. If leading with "0x" or "0X", it's heximal.
460 @param Data A pointer to the UINT64 value represented by Str
471 Str
= TrimHexStr (Str
, &IsHex
);
481 Converts a list of string to a specified buffer.
483 @param Buf The output buffer that contains the string.
484 @param BufferLength The length of the buffer
485 @param Str The input string that contains the hex number
487 @retval EFI_SUCCESS The string was successfully converted to the buffer.
493 IN UINTN BufferLength
,
505 // Two hex char make up one byte
507 StrLength
= BufferLength
* sizeof (CHAR16
);
509 for(Index
= 0; Index
< StrLength
; Index
++, Str
++) {
511 if ((*Str
>= L
'a') && (*Str
<= L
'f')) {
512 Digit
= (UINT8
) (*Str
- L
'a' + 0x0A);
513 } else if ((*Str
>= L
'A') && (*Str
<= L
'F')) {
514 Digit
= (UINT8
) (*Str
- L
'A' + 0x0A);
515 } else if ((*Str
>= L
'0') && (*Str
<= L
'9')) {
516 Digit
= (UINT8
) (*Str
- L
'0');
518 return EFI_INVALID_PARAMETER
;
522 // For odd charaters, write the upper nibble for each buffer byte,
523 // and for even characters, the lower nibble.
525 if ((Index
& 1) == 0) {
526 Byte
= (UINT8
) (Digit
<< 4);
528 Byte
= Buf
[Index
/ 2];
530 Byte
= (UINT8
) (Byte
| Digit
);
533 Buf
[Index
/ 2] = Byte
;
540 Converts a string to GUID value.
541 Guid Format is xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
543 @param Str The registry format GUID string that contains the GUID value.
544 @param Guid A pointer to the converted GUID value.
546 @retval EFI_SUCCESS The GUID string was successfully converted to the GUID value.
547 @retval EFI_UNSUPPORTED The input string is not in registry format.
548 @return others Some error occurred when converting part of GUID value.
558 // Get the first UINT32 data
560 Guid
->Data1
= (UINT32
) StrHexToUint64 (Str
);
561 while (!IS_HYPHEN (*Str
) && !IS_NULL (*Str
)) {
565 if (IS_HYPHEN (*Str
)) {
568 return EFI_UNSUPPORTED
;
572 // Get the second UINT16 data
574 Guid
->Data2
= (UINT16
) StrHexToUint64 (Str
);
575 while (!IS_HYPHEN (*Str
) && !IS_NULL (*Str
)) {
579 if (IS_HYPHEN (*Str
)) {
582 return EFI_UNSUPPORTED
;
586 // Get the third UINT16 data
588 Guid
->Data3
= (UINT16
) StrHexToUint64 (Str
);
589 while (!IS_HYPHEN (*Str
) && !IS_NULL (*Str
)) {
593 if (IS_HYPHEN (*Str
)) {
596 return EFI_UNSUPPORTED
;
600 // Get the followin 8 bytes data
602 StrToBuf (&Guid
->Data4
[0], 2, Str
);
604 // Skip 2 byte hex chars
608 if (IS_HYPHEN (*Str
)) {
611 return EFI_UNSUPPORTED
;
613 StrToBuf (&Guid
->Data4
[2], 6, Str
);
619 Converts a string to IPv4 address
621 @param Str A string representation of IPv4 address.
622 @param IPv4Addr A pointer to the converted IPv4 address.
628 OUT EFI_IPv4_ADDRESS
*IPv4Addr
633 for (Index
= 0; Index
< 4; Index
++) {
634 IPv4Addr
->Addr
[Index
] = (UINT8
) Dtoi (SplitStr (Str
, L
'.'));
639 Converts a string to IPv4 address
641 @param Str A string representation of IPv6 address.
642 @param IPv6Addr A pointer to the converted IPv6 address.
648 OUT EFI_IPv6_ADDRESS
*IPv6Addr
654 for (Index
= 0; Index
< 8; Index
++) {
655 Data
= (UINT16
) Xtoi (SplitStr (Str
, L
':'));
656 IPv6Addr
->Addr
[Index
* 2] = (UINT8
) (Data
>> 8);
657 IPv6Addr
->Addr
[Index
* 2 + 1] = (UINT8
) (Data
& 0xff);
662 Converts a Unicode string to ASCII string.
664 @param Str The equiventant Unicode string
665 @param AsciiStr On input, it points to destination ASCII string buffer; on output, it points
666 to the next ASCII string next to it
672 IN OUT CHAR8
**AsciiStr
678 while (!IS_NULL (*Str
)) {
679 *(Dest
++) = (CHAR8
) *(Str
++);
684 // Return the string next to it
686 *AsciiStr
= Dest
+ 1;
690 Converts a text device path node to Hardware PCI device path structure.
692 @param TextDeviceNode The input Text device path node.
694 @return A pointer to Hardware PCI device path structure.
697 EFI_DEVICE_PATH_PROTOCOL
*
699 IN CHAR16
*TextDeviceNode
704 PCI_DEVICE_PATH
*Pci
;
706 DeviceStr
= GetNextParamStr (&TextDeviceNode
);
707 FunctionStr
= GetNextParamStr (&TextDeviceNode
);
708 Pci
= (PCI_DEVICE_PATH
*) CreateDeviceNode (
709 HARDWARE_DEVICE_PATH
,
711 sizeof (PCI_DEVICE_PATH
)
714 Pci
->Function
= (UINT8
) Strtoi (FunctionStr
);
715 Pci
->Device
= (UINT8
) Strtoi (DeviceStr
);
717 return (EFI_DEVICE_PATH_PROTOCOL
*) Pci
;
721 Converts a text device path node to Hardware PC card device path structure.
723 @param TextDeviceNode The input Text device path node.
725 @return A pointer to Hardware PC card device path structure.
728 EFI_DEVICE_PATH_PROTOCOL
*
729 DevPathFromTextPcCard (
730 IN CHAR16
*TextDeviceNode
733 CHAR16
*FunctionNumberStr
;
734 PCCARD_DEVICE_PATH
*Pccard
;
736 FunctionNumberStr
= GetNextParamStr (&TextDeviceNode
);
737 Pccard
= (PCCARD_DEVICE_PATH
*) CreateDeviceNode (
738 HARDWARE_DEVICE_PATH
,
740 sizeof (PCCARD_DEVICE_PATH
)
743 Pccard
->FunctionNumber
= (UINT8
) Strtoi (FunctionNumberStr
);
745 return (EFI_DEVICE_PATH_PROTOCOL
*) Pccard
;
749 Converts a text device path node to Hardware memory map device path structure.
751 @param TextDeviceNode The input Text device path node.
753 @return A pointer to Hardware memory map device path structure.
756 EFI_DEVICE_PATH_PROTOCOL
*
757 DevPathFromTextMemoryMapped (
758 IN CHAR16
*TextDeviceNode
761 CHAR16
*MemoryTypeStr
;
762 CHAR16
*StartingAddressStr
;
763 CHAR16
*EndingAddressStr
;
764 MEMMAP_DEVICE_PATH
*MemMap
;
766 MemoryTypeStr
= GetNextParamStr (&TextDeviceNode
);
767 StartingAddressStr
= GetNextParamStr (&TextDeviceNode
);
768 EndingAddressStr
= GetNextParamStr (&TextDeviceNode
);
769 MemMap
= (MEMMAP_DEVICE_PATH
*) CreateDeviceNode (
770 HARDWARE_DEVICE_PATH
,
772 sizeof (MEMMAP_DEVICE_PATH
)
775 MemMap
->MemoryType
= (UINT32
) Strtoi (MemoryTypeStr
);
776 Strtoi64 (StartingAddressStr
, &MemMap
->StartingAddress
);
777 Strtoi64 (EndingAddressStr
, &MemMap
->EndingAddress
);
779 return (EFI_DEVICE_PATH_PROTOCOL
*) MemMap
;
783 Converts a text device path node to Vendor device path structure based on the input Type
786 @param TextDeviceNode The input Text device path node.
787 @param Type The type of device path node.
788 @param SubType The subtype of device path node.
790 @return A pointer to the newly-created Vendor device path structure.
793 EFI_DEVICE_PATH_PROTOCOL
*
794 ConvertFromTextVendor (
795 IN CHAR16
*TextDeviceNode
,
803 VENDOR_DEVICE_PATH
*Vendor
;
805 GuidStr
= GetNextParamStr (&TextDeviceNode
);
807 DataStr
= GetNextParamStr (&TextDeviceNode
);
808 Length
= StrLen (DataStr
);
810 // Two hex characters make up 1 buffer byte
812 Length
= (Length
+ 1) / 2;
814 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
817 (UINT16
) (sizeof (VENDOR_DEVICE_PATH
) + Length
)
820 StrToGuid (GuidStr
, &Vendor
->Guid
);
821 StrToBuf (((UINT8
*) Vendor
) + sizeof (VENDOR_DEVICE_PATH
), Length
, DataStr
);
823 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
827 Converts a text device path node to Vendor Hardware device path structure.
829 @param TextDeviceNode The input Text device path node.
831 @return A pointer to the newly-created Vendor Hardware device path structure.
834 EFI_DEVICE_PATH_PROTOCOL
*
835 DevPathFromTextVenHw (
836 IN CHAR16
*TextDeviceNode
839 return ConvertFromTextVendor (
841 HARDWARE_DEVICE_PATH
,
847 Converts a text device path node to Hardware Controller device path structure.
849 @param TextDeviceNode The input Text device path node.
851 @return A pointer to the newly-created Hardware Controller device path structure.
854 EFI_DEVICE_PATH_PROTOCOL
*
855 DevPathFromTextCtrl (
856 IN CHAR16
*TextDeviceNode
859 CHAR16
*ControllerStr
;
860 CONTROLLER_DEVICE_PATH
*Controller
;
862 ControllerStr
= GetNextParamStr (&TextDeviceNode
);
863 Controller
= (CONTROLLER_DEVICE_PATH
*) CreateDeviceNode (
864 HARDWARE_DEVICE_PATH
,
866 sizeof (CONTROLLER_DEVICE_PATH
)
868 Controller
->ControllerNumber
= (UINT32
) Strtoi (ControllerStr
);
870 return (EFI_DEVICE_PATH_PROTOCOL
*) Controller
;
874 Converts a string to EisaId.
876 @param Text The input string.
877 @param EisaId A pointer to the output EisaId.
888 PnpId
= Xtoi (Text
+ 3);
889 *EisaId
= (((Text
[0] - '@') & 0x1f) << 10) +
890 (((Text
[1] - '@') & 0x1f) << 5) +
891 ((Text
[2] - '@') & 0x1f) +
892 (UINT32
) (PnpId
<< 16);
896 Converts a text device path node to ACPI HID device path structure.
898 @param TextDeviceNode The input Text device path node.
900 @return A pointer to the newly-created ACPI HID device path structure.
903 EFI_DEVICE_PATH_PROTOCOL
*
904 DevPathFromTextAcpi (
905 IN CHAR16
*TextDeviceNode
910 ACPI_HID_DEVICE_PATH
*Acpi
;
912 HIDStr
= GetNextParamStr (&TextDeviceNode
);
913 UIDStr
= GetNextParamStr (&TextDeviceNode
);
914 Acpi
= (ACPI_HID_DEVICE_PATH
*) CreateDeviceNode (
917 sizeof (ACPI_HID_DEVICE_PATH
)
920 EisaIdFromText (HIDStr
, &Acpi
->HID
);
921 Acpi
->UID
= (UINT32
) Strtoi (UIDStr
);
923 return (EFI_DEVICE_PATH_PROTOCOL
*) Acpi
;
927 Converts a text device path node to ACPI HID device path structure.
929 @param TextDeviceNode The input Text device path node.
930 @param PnPId The input plug and play identification.
932 @return A pointer to the newly-created ACPI HID device path structure.
935 EFI_DEVICE_PATH_PROTOCOL
*
936 ConvertFromTextAcpi (
937 IN CHAR16
*TextDeviceNode
,
942 ACPI_HID_DEVICE_PATH
*Acpi
;
944 UIDStr
= GetNextParamStr (&TextDeviceNode
);
945 Acpi
= (ACPI_HID_DEVICE_PATH
*) CreateDeviceNode (
948 sizeof (ACPI_HID_DEVICE_PATH
)
951 Acpi
->HID
= EFI_PNP_ID (PnPId
);
952 Acpi
->UID
= (UINT32
) Strtoi (UIDStr
);
954 return (EFI_DEVICE_PATH_PROTOCOL
*) Acpi
;
958 Converts a text device path node to PCI root device path structure.
960 @param TextDeviceNode The input Text device path node.
962 @return A pointer to the newly-created PCI root device path structure.
965 EFI_DEVICE_PATH_PROTOCOL
*
966 DevPathFromTextPciRoot (
967 IN CHAR16
*TextDeviceNode
970 return ConvertFromTextAcpi (TextDeviceNode
, 0x0a03);
974 Converts a text device path node to Floppy device path structure.
976 @param TextDeviceNode The input Text device path node.
978 @return A pointer to the newly-created Floppy device path structure.
981 EFI_DEVICE_PATH_PROTOCOL
*
982 DevPathFromTextFloppy (
983 IN CHAR16
*TextDeviceNode
986 return ConvertFromTextAcpi (TextDeviceNode
, 0x0604);
990 Converts a text device path node to Keyboard device path structure.
992 @param TextDeviceNode The input Text device path node.
994 @return A pointer to the newly-created Keyboard device path structure.
997 EFI_DEVICE_PATH_PROTOCOL
*
998 DevPathFromTextKeyboard (
999 IN CHAR16
*TextDeviceNode
1002 return ConvertFromTextAcpi (TextDeviceNode
, 0x0301);
1006 Converts a text device path node to Serial device path structure.
1008 @param TextDeviceNode The input Text device path node.
1010 @return A pointer to the newly-created Serial device path structure.
1013 EFI_DEVICE_PATH_PROTOCOL
*
1014 DevPathFromTextSerial (
1015 IN CHAR16
*TextDeviceNode
1018 return ConvertFromTextAcpi (TextDeviceNode
, 0x0501);
1022 Converts a text device path node to Parallel Port device path structure.
1024 @param TextDeviceNode The input Text device path node.
1026 @return A pointer to the newly-created Parallel Port device path structure.
1029 EFI_DEVICE_PATH_PROTOCOL
*
1030 DevPathFromTextParallelPort (
1031 IN CHAR16
*TextDeviceNode
1034 return ConvertFromTextAcpi (TextDeviceNode
, 0x0401);
1038 Converts a text device path node to ACPI extention device path structure.
1040 @param TextDeviceNode The input Text device path node.
1042 @return A pointer to the newly-created ACPI extention device path structure.
1045 EFI_DEVICE_PATH_PROTOCOL
*
1046 DevPathFromTextAcpiEx (
1047 IN CHAR16
*TextDeviceNode
1058 ACPI_EXTENDED_HID_DEVICE_PATH
*AcpiEx
;
1060 HIDStr
= GetNextParamStr (&TextDeviceNode
);
1061 CIDStr
= GetNextParamStr (&TextDeviceNode
);
1062 UIDStr
= GetNextParamStr (&TextDeviceNode
);
1063 HIDSTRStr
= GetNextParamStr (&TextDeviceNode
);
1064 CIDSTRStr
= GetNextParamStr (&TextDeviceNode
);
1065 UIDSTRStr
= GetNextParamStr (&TextDeviceNode
);
1067 Length
= (UINT16
) (sizeof (ACPI_EXTENDED_HID_DEVICE_PATH
) + StrLen (HIDSTRStr
) + 1);
1068 Length
= (UINT16
) (Length
+ StrLen (UIDSTRStr
) + 1);
1069 Length
= (UINT16
) (Length
+ StrLen (CIDSTRStr
) + 1);
1070 AcpiEx
= (ACPI_EXTENDED_HID_DEVICE_PATH
*) CreateDeviceNode (
1076 EisaIdFromText (HIDStr
, &AcpiEx
->HID
);
1077 EisaIdFromText (CIDStr
, &AcpiEx
->CID
);
1078 AcpiEx
->UID
= (UINT32
) Strtoi (UIDStr
);
1080 AsciiStr
= (CHAR8
*) ((UINT8
*)AcpiEx
+ sizeof (ACPI_EXTENDED_HID_DEVICE_PATH
));
1081 StrToAscii (HIDSTRStr
, &AsciiStr
);
1082 StrToAscii (UIDSTRStr
, &AsciiStr
);
1083 StrToAscii (CIDSTRStr
, &AsciiStr
);
1085 return (EFI_DEVICE_PATH_PROTOCOL
*) AcpiEx
;
1089 Converts a text device path node to ACPI extention device path structure.
1091 @param TextDeviceNode The input Text device path node.
1093 @return A pointer to the newly-created ACPI extention device path structure.
1096 EFI_DEVICE_PATH_PROTOCOL
*
1097 DevPathFromTextAcpiExp (
1098 IN CHAR16
*TextDeviceNode
1106 ACPI_EXTENDED_HID_DEVICE_PATH
*AcpiEx
;
1108 HIDStr
= GetNextParamStr (&TextDeviceNode
);
1109 CIDStr
= GetNextParamStr (&TextDeviceNode
);
1110 UIDSTRStr
= GetNextParamStr (&TextDeviceNode
);
1111 Length
= (UINT16
) (sizeof (ACPI_EXTENDED_HID_DEVICE_PATH
) + StrLen (UIDSTRStr
) + 3);
1112 AcpiEx
= (ACPI_EXTENDED_HID_DEVICE_PATH
*) CreateDeviceNode (
1118 EisaIdFromText (HIDStr
, &AcpiEx
->HID
);
1119 EisaIdFromText (CIDStr
, &AcpiEx
->CID
);
1122 AsciiStr
= (CHAR8
*) ((UINT8
*)AcpiEx
+ sizeof (ACPI_EXTENDED_HID_DEVICE_PATH
));
1124 // HID string is NULL
1128 // Convert UID string
1131 StrToAscii (UIDSTRStr
, &AsciiStr
);
1133 // CID string is NULL
1137 return (EFI_DEVICE_PATH_PROTOCOL
*) AcpiEx
;
1141 Converts a text device path node to Parallel Port device path structure.
1143 @param TextDeviceNode The input Text device path node.
1145 @return A pointer to the newly-created Parallel Port device path structure.
1148 EFI_DEVICE_PATH_PROTOCOL
*
1149 DevPathFromTextAta (
1150 IN CHAR16
*TextDeviceNode
1153 CHAR16
*PrimarySecondaryStr
;
1154 CHAR16
*SlaveMasterStr
;
1156 ATAPI_DEVICE_PATH
*Atapi
;
1158 Atapi
= (ATAPI_DEVICE_PATH
*) CreateDeviceNode (
1159 MESSAGING_DEVICE_PATH
,
1161 sizeof (ATAPI_DEVICE_PATH
)
1164 PrimarySecondaryStr
= GetNextParamStr (&TextDeviceNode
);
1165 SlaveMasterStr
= GetNextParamStr (&TextDeviceNode
);
1166 LunStr
= GetNextParamStr (&TextDeviceNode
);
1168 Atapi
->PrimarySecondary
= (UINT8
) ((StrCmp (PrimarySecondaryStr
, L
"Primary") == 0) ? 0 : 1);
1169 Atapi
->SlaveMaster
= (UINT8
) ((StrCmp (SlaveMasterStr
, L
"Master") == 0) ? 0 : 1);
1170 Atapi
->Lun
= (UINT16
) Strtoi (LunStr
);
1172 return (EFI_DEVICE_PATH_PROTOCOL
*) Atapi
;
1176 Converts a text device path node to SCSI device path structure.
1178 @param TextDeviceNode The input Text device path node.
1180 @return A pointer to the newly-created SCSI device path structure.
1183 EFI_DEVICE_PATH_PROTOCOL
*
1184 DevPathFromTextScsi (
1185 IN CHAR16
*TextDeviceNode
1190 SCSI_DEVICE_PATH
*Scsi
;
1192 PunStr
= GetNextParamStr (&TextDeviceNode
);
1193 LunStr
= GetNextParamStr (&TextDeviceNode
);
1194 Scsi
= (SCSI_DEVICE_PATH
*) CreateDeviceNode (
1195 MESSAGING_DEVICE_PATH
,
1197 sizeof (SCSI_DEVICE_PATH
)
1200 Scsi
->Pun
= (UINT16
) Strtoi (PunStr
);
1201 Scsi
->Lun
= (UINT16
) Strtoi (LunStr
);
1203 return (EFI_DEVICE_PATH_PROTOCOL
*) Scsi
;
1207 Converts a text device path node to Fibre device path structure.
1209 @param TextDeviceNode The input Text device path node.
1211 @return A pointer to the newly-created Fibre device path structure.
1214 EFI_DEVICE_PATH_PROTOCOL
*
1215 DevPathFromTextFibre (
1216 IN CHAR16
*TextDeviceNode
1221 FIBRECHANNEL_DEVICE_PATH
*Fibre
;
1223 WWNStr
= GetNextParamStr (&TextDeviceNode
);
1224 LunStr
= GetNextParamStr (&TextDeviceNode
);
1225 Fibre
= (FIBRECHANNEL_DEVICE_PATH
*) CreateDeviceNode (
1226 MESSAGING_DEVICE_PATH
,
1227 MSG_FIBRECHANNEL_DP
,
1228 sizeof (FIBRECHANNEL_DEVICE_PATH
)
1231 Fibre
->Reserved
= 0;
1232 Strtoi64 (WWNStr
, &Fibre
->WWN
);
1233 Strtoi64 (LunStr
, &Fibre
->Lun
);
1235 return (EFI_DEVICE_PATH_PROTOCOL
*) Fibre
;
1239 Converts a text device path node to 1394 device path structure.
1241 @param TextDeviceNode The input Text device path node.
1243 @return A pointer to the newly-created 1394 device path structure.
1246 EFI_DEVICE_PATH_PROTOCOL
*
1247 DevPathFromText1394 (
1248 IN CHAR16
*TextDeviceNode
1252 F1394_DEVICE_PATH
*F1394DevPath
;
1254 GuidStr
= GetNextParamStr (&TextDeviceNode
);
1255 F1394DevPath
= (F1394_DEVICE_PATH
*) CreateDeviceNode (
1256 MESSAGING_DEVICE_PATH
,
1258 sizeof (F1394_DEVICE_PATH
)
1261 F1394DevPath
->Reserved
= 0;
1262 Xtoi64 (GuidStr
, &F1394DevPath
->Guid
);
1264 return (EFI_DEVICE_PATH_PROTOCOL
*) F1394DevPath
;
1268 Converts a text device path node to USB device path structure.
1270 @param TextDeviceNode The input Text device path node.
1272 @return A pointer to the newly-created USB device path structure.
1275 EFI_DEVICE_PATH_PROTOCOL
*
1276 DevPathFromTextUsb (
1277 IN CHAR16
*TextDeviceNode
1281 CHAR16
*InterfaceStr
;
1282 USB_DEVICE_PATH
*Usb
;
1284 PortStr
= GetNextParamStr (&TextDeviceNode
);
1285 InterfaceStr
= GetNextParamStr (&TextDeviceNode
);
1286 Usb
= (USB_DEVICE_PATH
*) CreateDeviceNode (
1287 MESSAGING_DEVICE_PATH
,
1289 sizeof (USB_DEVICE_PATH
)
1292 Usb
->ParentPortNumber
= (UINT8
) Strtoi (PortStr
);
1293 Usb
->InterfaceNumber
= (UINT8
) Strtoi (InterfaceStr
);
1295 return (EFI_DEVICE_PATH_PROTOCOL
*) Usb
;
1299 Converts a text device path node to I20 device path structure.
1301 @param TextDeviceNode The input Text device path node.
1303 @return A pointer to the newly-created I20 device path structure.
1306 EFI_DEVICE_PATH_PROTOCOL
*
1307 DevPathFromTextI2O (
1308 IN CHAR16
*TextDeviceNode
1312 I2O_DEVICE_PATH
*I2ODevPath
;
1314 TIDStr
= GetNextParamStr (&TextDeviceNode
);
1315 I2ODevPath
= (I2O_DEVICE_PATH
*) CreateDeviceNode (
1316 MESSAGING_DEVICE_PATH
,
1318 sizeof (I2O_DEVICE_PATH
)
1321 I2ODevPath
->Tid
= (UINT32
) Strtoi (TIDStr
);
1323 return (EFI_DEVICE_PATH_PROTOCOL
*) I2ODevPath
;
1327 Converts a text device path node to Infini Band device path structure.
1329 @param TextDeviceNode The input Text device path node.
1331 @return A pointer to the newly-created Infini Band device path structure.
1334 EFI_DEVICE_PATH_PROTOCOL
*
1335 DevPathFromTextInfiniband (
1336 IN CHAR16
*TextDeviceNode
1345 INFINIBAND_DEVICE_PATH
*InfiniBand
;
1347 FlagsStr
= GetNextParamStr (&TextDeviceNode
);
1348 GuidStr
= GetNextParamStr (&TextDeviceNode
);
1349 SidStr
= GetNextParamStr (&TextDeviceNode
);
1350 TidStr
= GetNextParamStr (&TextDeviceNode
);
1351 DidStr
= GetNextParamStr (&TextDeviceNode
);
1352 InfiniBand
= (INFINIBAND_DEVICE_PATH
*) CreateDeviceNode (
1353 MESSAGING_DEVICE_PATH
,
1355 sizeof (INFINIBAND_DEVICE_PATH
)
1358 InfiniBand
->ResourceFlags
= (UINT32
) Strtoi (FlagsStr
);
1359 StrToGuid (GuidStr
, &PortGid
);
1360 CopyMem (InfiniBand
->PortGid
, &PortGid
, sizeof (EFI_GUID
));
1361 Strtoi64 (SidStr
, &InfiniBand
->ServiceId
);
1362 Strtoi64 (TidStr
, &InfiniBand
->TargetPortId
);
1363 Strtoi64 (DidStr
, &InfiniBand
->DeviceId
);
1365 return (EFI_DEVICE_PATH_PROTOCOL
*) InfiniBand
;
1369 Converts a text device path node to Vendor-Defined Messaging device path structure.
1371 @param TextDeviceNode The input Text device path node.
1373 @return A pointer to the newly-created Vendor-Defined Messaging device path structure.
1376 EFI_DEVICE_PATH_PROTOCOL
*
1377 DevPathFromTextVenMsg (
1378 IN CHAR16
*TextDeviceNode
1381 return ConvertFromTextVendor (
1383 MESSAGING_DEVICE_PATH
,
1389 Converts a text device path node to Vendor defined PC-ANSI device path structure.
1391 @param TextDeviceNode The input Text device path node.
1393 @return A pointer to the newly-created Vendor defined PC-ANSI device path structure.
1396 EFI_DEVICE_PATH_PROTOCOL
*
1397 DevPathFromTextVenPcAnsi (
1398 IN CHAR16
*TextDeviceNode
1401 VENDOR_DEVICE_PATH
*Vendor
;
1403 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
1404 MESSAGING_DEVICE_PATH
,
1406 sizeof (VENDOR_DEVICE_PATH
));
1407 CopyGuid (&Vendor
->Guid
, &gEfiPcAnsiGuid
);
1409 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
1413 Converts a text device path node to Vendor defined VT100 device path structure.
1415 @param TextDeviceNode The input Text device path node.
1417 @return A pointer to the newly-created Vendor defined VT100 device path structure.
1420 EFI_DEVICE_PATH_PROTOCOL
*
1421 DevPathFromTextVenVt100 (
1422 IN CHAR16
*TextDeviceNode
1425 VENDOR_DEVICE_PATH
*Vendor
;
1427 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
1428 MESSAGING_DEVICE_PATH
,
1430 sizeof (VENDOR_DEVICE_PATH
));
1431 CopyGuid (&Vendor
->Guid
, &gEfiVT100Guid
);
1433 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
1437 Converts a text device path node to Vendor defined VT100 Plus device path structure.
1439 @param TextDeviceNode The input Text device path node.
1441 @return A pointer to the newly-created Vendor defined VT100 Plus device path structure.
1444 EFI_DEVICE_PATH_PROTOCOL
*
1445 DevPathFromTextVenVt100Plus (
1446 IN CHAR16
*TextDeviceNode
1449 VENDOR_DEVICE_PATH
*Vendor
;
1451 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
1452 MESSAGING_DEVICE_PATH
,
1454 sizeof (VENDOR_DEVICE_PATH
));
1455 CopyGuid (&Vendor
->Guid
, &gEfiVT100PlusGuid
);
1457 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
1461 Converts a text device path node to Vendor defined UTF8 device path structure.
1463 @param TextDeviceNode The input Text device path node.
1465 @return A pointer to the newly-created Vendor defined UTF8 device path structure.
1468 EFI_DEVICE_PATH_PROTOCOL
*
1469 DevPathFromTextVenUtf8 (
1470 IN CHAR16
*TextDeviceNode
1473 VENDOR_DEVICE_PATH
*Vendor
;
1475 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
1476 MESSAGING_DEVICE_PATH
,
1478 sizeof (VENDOR_DEVICE_PATH
));
1479 CopyGuid (&Vendor
->Guid
, &gEfiVTUTF8Guid
);
1481 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
1485 Converts a text device path node to UART Flow Control device path structure.
1487 @param TextDeviceNode The input Text device path node.
1489 @return A pointer to the newly-created UART Flow Control device path structure.
1492 EFI_DEVICE_PATH_PROTOCOL
*
1493 DevPathFromTextUartFlowCtrl (
1494 IN CHAR16
*TextDeviceNode
1498 UART_FLOW_CONTROL_DEVICE_PATH
*UartFlowControl
;
1500 ValueStr
= GetNextParamStr (&TextDeviceNode
);
1501 UartFlowControl
= (UART_FLOW_CONTROL_DEVICE_PATH
*) CreateDeviceNode (
1502 MESSAGING_DEVICE_PATH
,
1504 sizeof (UART_FLOW_CONTROL_DEVICE_PATH
)
1507 CopyGuid (&UartFlowControl
->Guid
, &gEfiUartDevicePathGuid
);
1508 if (StrCmp (ValueStr
, L
"XonXoff") == 0) {
1509 UartFlowControl
->FlowControlMap
= 2;
1510 } else if (StrCmp (ValueStr
, L
"Hardware") == 0) {
1511 UartFlowControl
->FlowControlMap
= 1;
1513 UartFlowControl
->FlowControlMap
= 0;
1516 return (EFI_DEVICE_PATH_PROTOCOL
*) UartFlowControl
;
1520 Converts a text device path node to Serial Attached SCSI device path structure.
1522 @param TextDeviceNode The input Text device path node.
1524 @return A pointer to the newly-created Serial Attached SCSI device path structure.
1527 EFI_DEVICE_PATH_PROTOCOL
*
1528 DevPathFromTextSAS (
1529 IN CHAR16
*TextDeviceNode
1536 CHAR16
*LocationStr
;
1538 CHAR16
*DriveBayStr
;
1539 CHAR16
*ReservedStr
;
1541 SAS_DEVICE_PATH
*Sas
;
1543 AddressStr
= GetNextParamStr (&TextDeviceNode
);
1544 LunStr
= GetNextParamStr (&TextDeviceNode
);
1545 RTPStr
= GetNextParamStr (&TextDeviceNode
);
1546 SASSATAStr
= GetNextParamStr (&TextDeviceNode
);
1547 LocationStr
= GetNextParamStr (&TextDeviceNode
);
1548 ConnectStr
= GetNextParamStr (&TextDeviceNode
);
1549 DriveBayStr
= GetNextParamStr (&TextDeviceNode
);
1550 ReservedStr
= GetNextParamStr (&TextDeviceNode
);
1552 Sas
= (SAS_DEVICE_PATH
*) CreateDeviceNode (
1553 MESSAGING_DEVICE_PATH
,
1555 sizeof (SAS_DEVICE_PATH
)
1558 CopyGuid (&Sas
->Guid
, &gEfiSasDevicePathGuid
);
1559 Strtoi64 (AddressStr
, &Sas
->SasAddress
);
1560 Strtoi64 (LunStr
, &Sas
->Lun
);
1561 Sas
->RelativeTargetPort
= (UINT16
) Strtoi (RTPStr
);
1562 if (StrCmp (SASSATAStr
, L
"NoTopology") != 0) {
1563 if (StrCmp (DriveBayStr
, L
"0") == 0) {
1567 Info
= (UINT16
) (Info
| (Strtoi (DriveBayStr
) << 8));
1570 if (StrCmp (SASSATAStr
, L
"SATA") == 0) {
1574 if (StrCmp (LocationStr
, L
"External") == 0) {
1578 if (StrCmp (ConnectStr
, L
"Expanded") == 0) {
1583 Sas
->DeviceTopology
= Info
;
1584 Sas
->Reserved
= (UINT32
) Strtoi (ReservedStr
);
1586 return (EFI_DEVICE_PATH_PROTOCOL
*) Sas
;
1590 Converts a text device path node to Debug Port device path structure.
1592 @param TextDeviceNode The input Text device path node.
1594 @return A pointer to the newly-created Debug Port device path structure.
1597 EFI_DEVICE_PATH_PROTOCOL
*
1598 DevPathFromTextDebugPort (
1599 IN CHAR16
*TextDeviceNode
1602 VENDOR_DEFINED_MESSAGING_DEVICE_PATH
*Vend
;
1604 Vend
= (VENDOR_DEFINED_MESSAGING_DEVICE_PATH
*) CreateDeviceNode (
1605 MESSAGING_DEVICE_PATH
,
1607 sizeof (VENDOR_DEFINED_MESSAGING_DEVICE_PATH
)
1610 CopyGuid (&Vend
->Guid
, &gEfiDebugPortProtocolGuid
);
1612 return (EFI_DEVICE_PATH_PROTOCOL
*) Vend
;
1616 Converts a text device path node to MAC device path structure.
1618 @param TextDeviceNode The input Text device path node.
1620 @return A pointer to the newly-created MAC device path structure.
1623 EFI_DEVICE_PATH_PROTOCOL
*
1624 DevPathFromTextMAC (
1625 IN CHAR16
*TextDeviceNode
1631 MAC_ADDR_DEVICE_PATH
*MACDevPath
;
1633 AddressStr
= GetNextParamStr (&TextDeviceNode
);
1634 IfTypeStr
= GetNextParamStr (&TextDeviceNode
);
1635 MACDevPath
= (MAC_ADDR_DEVICE_PATH
*) CreateDeviceNode (
1636 MESSAGING_DEVICE_PATH
,
1638 sizeof (MAC_ADDR_DEVICE_PATH
)
1641 MACDevPath
->IfType
= (UINT8
) Strtoi (IfTypeStr
);
1643 Length
= sizeof (EFI_MAC_ADDRESS
);
1644 StrToBuf (&MACDevPath
->MacAddress
.Addr
[0], Length
, AddressStr
);
1646 return (EFI_DEVICE_PATH_PROTOCOL
*) MACDevPath
;
1650 Converts a text device path node to IPV4 device path structure.
1652 @param TextDeviceNode The input Text device path node.
1654 @return A pointer to the newly-created IPV4 device path structure.
1657 EFI_DEVICE_PATH_PROTOCOL
*
1658 DevPathFromTextIPv4 (
1659 IN CHAR16
*TextDeviceNode
1662 CHAR16
*RemoteIPStr
;
1663 CHAR16
*ProtocolStr
;
1666 IPv4_DEVICE_PATH
*IPv4
;
1668 RemoteIPStr
= GetNextParamStr (&TextDeviceNode
);
1669 ProtocolStr
= GetNextParamStr (&TextDeviceNode
);
1670 TypeStr
= GetNextParamStr (&TextDeviceNode
);
1671 LocalIPStr
= GetNextParamStr (&TextDeviceNode
);
1672 IPv4
= (IPv4_DEVICE_PATH
*) CreateDeviceNode (
1673 MESSAGING_DEVICE_PATH
,
1675 sizeof (IPv4_DEVICE_PATH
)
1678 StrToIPv4Addr (&RemoteIPStr
, &IPv4
->RemoteIpAddress
);
1679 IPv4
->Protocol
= (UINT16
) ((StrCmp (ProtocolStr
, L
"UDP") == 0) ? 0 : 1);
1680 if (StrCmp (TypeStr
, L
"Static") == 0) {
1681 IPv4
->StaticIpAddress
= TRUE
;
1683 IPv4
->StaticIpAddress
= FALSE
;
1686 StrToIPv4Addr (&LocalIPStr
, &IPv4
->LocalIpAddress
);
1688 IPv4
->LocalPort
= 0;
1689 IPv4
->RemotePort
= 0;
1691 return (EFI_DEVICE_PATH_PROTOCOL
*) IPv4
;
1695 Converts a text device path node to IPV6 device path structure.
1697 @param TextDeviceNode The input Text device path node.
1699 @return A pointer to the newly-created IPV6 device path structure.
1702 EFI_DEVICE_PATH_PROTOCOL
*
1703 DevPathFromTextIPv6 (
1704 IN CHAR16
*TextDeviceNode
1707 CHAR16
*RemoteIPStr
;
1708 CHAR16
*ProtocolStr
;
1711 IPv6_DEVICE_PATH
*IPv6
;
1713 RemoteIPStr
= GetNextParamStr (&TextDeviceNode
);
1714 ProtocolStr
= GetNextParamStr (&TextDeviceNode
);
1715 TypeStr
= GetNextParamStr (&TextDeviceNode
);
1716 LocalIPStr
= GetNextParamStr (&TextDeviceNode
);
1717 IPv6
= (IPv6_DEVICE_PATH
*) CreateDeviceNode (
1718 MESSAGING_DEVICE_PATH
,
1720 sizeof (IPv6_DEVICE_PATH
)
1723 StrToIPv6Addr (&RemoteIPStr
, &IPv6
->RemoteIpAddress
);
1724 IPv6
->Protocol
= (UINT16
) ((StrCmp (ProtocolStr
, L
"UDP") == 0) ? 0 : 1);
1725 if (StrCmp (TypeStr
, L
"Static") == 0) {
1726 IPv6
->StaticIpAddress
= TRUE
;
1728 IPv6
->StaticIpAddress
= FALSE
;
1731 StrToIPv6Addr (&LocalIPStr
, &IPv6
->LocalIpAddress
);
1733 IPv6
->LocalPort
= 0;
1734 IPv6
->RemotePort
= 0;
1736 return (EFI_DEVICE_PATH_PROTOCOL
*) IPv6
;
1740 Converts a text device path node to UART device path structure.
1742 @param TextDeviceNode The input Text device path node.
1744 @return A pointer to the newly-created UART device path structure.
1747 EFI_DEVICE_PATH_PROTOCOL
*
1748 DevPathFromTextUart (
1749 IN CHAR16
*TextDeviceNode
1753 CHAR16
*DataBitsStr
;
1755 CHAR16
*StopBitsStr
;
1756 UART_DEVICE_PATH
*Uart
;
1758 BaudStr
= GetNextParamStr (&TextDeviceNode
);
1759 DataBitsStr
= GetNextParamStr (&TextDeviceNode
);
1760 ParityStr
= GetNextParamStr (&TextDeviceNode
);
1761 StopBitsStr
= GetNextParamStr (&TextDeviceNode
);
1762 Uart
= (UART_DEVICE_PATH
*) CreateDeviceNode (
1763 MESSAGING_DEVICE_PATH
,
1765 sizeof (UART_DEVICE_PATH
)
1768 Uart
->BaudRate
= (StrCmp (BaudStr
, L
"DEFAULT") == 0) ? 115200 : Dtoi (BaudStr
);
1769 Uart
->DataBits
= (UINT8
) ((StrCmp (DataBitsStr
, L
"DEFAULT") == 0) ? 8 : Dtoi (DataBitsStr
));
1770 switch (*ParityStr
) {
1795 Uart
->Parity
= 0xff;
1798 if (StrCmp (StopBitsStr
, L
"D") == 0) {
1799 Uart
->StopBits
= (UINT8
) 0;
1800 } else if (StrCmp (StopBitsStr
, L
"1") == 0) {
1801 Uart
->StopBits
= (UINT8
) 1;
1802 } else if (StrCmp (StopBitsStr
, L
"1.5") == 0) {
1803 Uart
->StopBits
= (UINT8
) 2;
1804 } else if (StrCmp (StopBitsStr
, L
"2") == 0) {
1805 Uart
->StopBits
= (UINT8
) 3;
1807 Uart
->StopBits
= 0xff;
1810 return (EFI_DEVICE_PATH_PROTOCOL
*) Uart
;
1814 Converts a text device path node to USB class device path structure.
1816 @param TextDeviceNode The input Text device path node.
1817 @param UsbClassText A pointer to USB_CLASS_TEXT structure to be integrated to USB Class Text.
1819 @return A pointer to the newly-created USB class device path structure.
1822 EFI_DEVICE_PATH_PROTOCOL
*
1823 ConvertFromTextUsbClass (
1824 IN CHAR16
*TextDeviceNode
,
1825 IN USB_CLASS_TEXT
*UsbClassText
1831 CHAR16
*SubClassStr
;
1832 CHAR16
*ProtocolStr
;
1833 USB_CLASS_DEVICE_PATH
*UsbClass
;
1835 UsbClass
= (USB_CLASS_DEVICE_PATH
*) CreateDeviceNode (
1836 MESSAGING_DEVICE_PATH
,
1838 sizeof (USB_CLASS_DEVICE_PATH
)
1841 VIDStr
= GetNextParamStr (&TextDeviceNode
);
1842 PIDStr
= GetNextParamStr (&TextDeviceNode
);
1843 if (UsbClassText
->ClassExist
) {
1844 ClassStr
= GetNextParamStr (&TextDeviceNode
);
1845 UsbClass
->DeviceClass
= (UINT8
) Strtoi (ClassStr
);
1847 UsbClass
->DeviceClass
= UsbClassText
->Class
;
1849 if (UsbClassText
->SubClassExist
) {
1850 SubClassStr
= GetNextParamStr (&TextDeviceNode
);
1851 UsbClass
->DeviceSubClass
= (UINT8
) Strtoi (SubClassStr
);
1853 UsbClass
->DeviceSubClass
= UsbClassText
->SubClass
;
1856 ProtocolStr
= GetNextParamStr (&TextDeviceNode
);
1858 UsbClass
->VendorId
= (UINT16
) Strtoi (VIDStr
);
1859 UsbClass
->ProductId
= (UINT16
) Strtoi (PIDStr
);
1860 UsbClass
->DeviceProtocol
= (UINT8
) Strtoi (ProtocolStr
);
1862 return (EFI_DEVICE_PATH_PROTOCOL
*) UsbClass
;
1867 Converts a text device path node to USB class device path structure.
1869 @param TextDeviceNode The input Text device path node.
1871 @return A pointer to the newly-created USB class device path structure.
1874 EFI_DEVICE_PATH_PROTOCOL
*
1875 DevPathFromTextUsbClass (
1876 IN CHAR16
*TextDeviceNode
1879 USB_CLASS_TEXT UsbClassText
;
1881 UsbClassText
.ClassExist
= TRUE
;
1882 UsbClassText
.SubClassExist
= TRUE
;
1884 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1888 Converts a text device path node to USB audio device path structure.
1890 @param TextDeviceNode The input Text device path node.
1892 @return A pointer to the newly-created USB audio device path structure.
1895 EFI_DEVICE_PATH_PROTOCOL
*
1896 DevPathFromTextUsbAudio (
1897 IN CHAR16
*TextDeviceNode
1900 USB_CLASS_TEXT UsbClassText
;
1902 UsbClassText
.ClassExist
= FALSE
;
1903 UsbClassText
.Class
= USB_CLASS_AUDIO
;
1904 UsbClassText
.SubClassExist
= TRUE
;
1906 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1910 Converts a text device path node to USB CDC Control device path structure.
1912 @param TextDeviceNode The input Text device path node.
1914 @return A pointer to the newly-created USB CDC Control device path structure.
1917 EFI_DEVICE_PATH_PROTOCOL
*
1918 DevPathFromTextUsbCDCControl (
1919 IN CHAR16
*TextDeviceNode
1922 USB_CLASS_TEXT UsbClassText
;
1924 UsbClassText
.ClassExist
= FALSE
;
1925 UsbClassText
.Class
= USB_CLASS_CDCCONTROL
;
1926 UsbClassText
.SubClassExist
= TRUE
;
1928 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1932 Converts a text device path node to USB HID device path structure.
1934 @param TextDeviceNode The input Text device path node.
1936 @return A pointer to the newly-created USB HID device path structure.
1939 EFI_DEVICE_PATH_PROTOCOL
*
1940 DevPathFromTextUsbHID (
1941 IN CHAR16
*TextDeviceNode
1944 USB_CLASS_TEXT UsbClassText
;
1946 UsbClassText
.ClassExist
= FALSE
;
1947 UsbClassText
.Class
= USB_CLASS_HID
;
1948 UsbClassText
.SubClassExist
= TRUE
;
1950 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1954 Converts a text device path node to USB Image device path structure.
1956 @param TextDeviceNode The input Text device path node.
1958 @return A pointer to the newly-created USB Image device path structure.
1961 EFI_DEVICE_PATH_PROTOCOL
*
1962 DevPathFromTextUsbImage (
1963 IN CHAR16
*TextDeviceNode
1966 USB_CLASS_TEXT UsbClassText
;
1968 UsbClassText
.ClassExist
= FALSE
;
1969 UsbClassText
.Class
= USB_CLASS_IMAGE
;
1970 UsbClassText
.SubClassExist
= TRUE
;
1972 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1976 Converts a text device path node to USB Print device path structure.
1978 @param TextDeviceNode The input Text device path node.
1980 @return A pointer to the newly-created USB Print device path structure.
1983 EFI_DEVICE_PATH_PROTOCOL
*
1984 DevPathFromTextUsbPrinter (
1985 IN CHAR16
*TextDeviceNode
1988 USB_CLASS_TEXT UsbClassText
;
1990 UsbClassText
.ClassExist
= FALSE
;
1991 UsbClassText
.Class
= USB_CLASS_PRINTER
;
1992 UsbClassText
.SubClassExist
= TRUE
;
1994 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
1998 Converts a text device path node to USB mass storage device path structure.
2000 @param TextDeviceNode The input Text device path node.
2002 @return A pointer to the newly-created USB mass storage device path structure.
2005 EFI_DEVICE_PATH_PROTOCOL
*
2006 DevPathFromTextUsbMassStorage (
2007 IN CHAR16
*TextDeviceNode
2010 USB_CLASS_TEXT UsbClassText
;
2012 UsbClassText
.ClassExist
= FALSE
;
2013 UsbClassText
.Class
= USB_CLASS_MASS_STORAGE
;
2014 UsbClassText
.SubClassExist
= TRUE
;
2016 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
2020 Converts a text device path node to USB HUB device path structure.
2022 @param TextDeviceNode The input Text device path node.
2024 @return A pointer to the newly-created USB HUB device path structure.
2027 EFI_DEVICE_PATH_PROTOCOL
*
2028 DevPathFromTextUsbHub (
2029 IN CHAR16
*TextDeviceNode
2032 USB_CLASS_TEXT UsbClassText
;
2034 UsbClassText
.ClassExist
= FALSE
;
2035 UsbClassText
.Class
= USB_CLASS_HUB
;
2036 UsbClassText
.SubClassExist
= TRUE
;
2038 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
2042 Converts a text device path node to USB CDC data device path structure.
2044 @param TextDeviceNode The input Text device path node.
2046 @return A pointer to the newly-created USB CDC data device path structure.
2049 EFI_DEVICE_PATH_PROTOCOL
*
2050 DevPathFromTextUsbCDCData (
2051 IN CHAR16
*TextDeviceNode
2054 USB_CLASS_TEXT UsbClassText
;
2056 UsbClassText
.ClassExist
= FALSE
;
2057 UsbClassText
.Class
= USB_CLASS_CDCDATA
;
2058 UsbClassText
.SubClassExist
= TRUE
;
2060 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
2064 Converts a text device path node to USB smart card device path structure.
2066 @param TextDeviceNode The input Text device path node.
2068 @return A pointer to the newly-created USB smart card device path structure.
2071 EFI_DEVICE_PATH_PROTOCOL
*
2072 DevPathFromTextUsbSmartCard (
2073 IN CHAR16
*TextDeviceNode
2076 USB_CLASS_TEXT UsbClassText
;
2078 UsbClassText
.ClassExist
= FALSE
;
2079 UsbClassText
.Class
= USB_CLASS_SMART_CARD
;
2080 UsbClassText
.SubClassExist
= TRUE
;
2082 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
2086 Converts a text device path node to USB video device path structure.
2088 @param TextDeviceNode The input Text device path node.
2090 @return A pointer to the newly-created USB video device path structure.
2093 EFI_DEVICE_PATH_PROTOCOL
*
2094 DevPathFromTextUsbVideo (
2095 IN CHAR16
*TextDeviceNode
2098 USB_CLASS_TEXT UsbClassText
;
2100 UsbClassText
.ClassExist
= FALSE
;
2101 UsbClassText
.Class
= USB_CLASS_VIDEO
;
2102 UsbClassText
.SubClassExist
= TRUE
;
2104 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
2108 Converts a text device path node to USB diagnostic device path structure.
2110 @param TextDeviceNode The input Text device path node.
2112 @return A pointer to the newly-created USB diagnostic device path structure.
2115 EFI_DEVICE_PATH_PROTOCOL
*
2116 DevPathFromTextUsbDiagnostic (
2117 IN CHAR16
*TextDeviceNode
2120 USB_CLASS_TEXT UsbClassText
;
2122 UsbClassText
.ClassExist
= FALSE
;
2123 UsbClassText
.Class
= USB_CLASS_DIAGNOSTIC
;
2124 UsbClassText
.SubClassExist
= TRUE
;
2126 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
2130 Converts a text device path node to USB wireless device path structure.
2132 @param TextDeviceNode The input Text device path node.
2134 @return A pointer to the newly-created USB wireless device path structure.
2137 EFI_DEVICE_PATH_PROTOCOL
*
2138 DevPathFromTextUsbWireless (
2139 IN CHAR16
*TextDeviceNode
2142 USB_CLASS_TEXT UsbClassText
;
2144 UsbClassText
.ClassExist
= FALSE
;
2145 UsbClassText
.Class
= USB_CLASS_WIRELESS
;
2146 UsbClassText
.SubClassExist
= TRUE
;
2148 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
2152 Converts a text device path node to USB device firmware update device path structure.
2154 @param TextDeviceNode The input Text device path node.
2156 @return A pointer to the newly-created USB device firmware update device path structure.
2159 EFI_DEVICE_PATH_PROTOCOL
*
2160 DevPathFromTextUsbDeviceFirmwareUpdate (
2161 IN CHAR16
*TextDeviceNode
2164 USB_CLASS_TEXT UsbClassText
;
2166 UsbClassText
.ClassExist
= FALSE
;
2167 UsbClassText
.Class
= USB_CLASS_RESERVE
;
2168 UsbClassText
.SubClassExist
= FALSE
;
2169 UsbClassText
.SubClass
= USB_SUBCLASS_FW_UPDATE
;
2171 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
2175 Converts a text device path node to USB IRDA bridge device path structure.
2177 @param TextDeviceNode The input Text device path node.
2179 @return A pointer to the newly-created USB IRDA bridge device path structure.
2182 EFI_DEVICE_PATH_PROTOCOL
*
2183 DevPathFromTextUsbIrdaBridge (
2184 IN CHAR16
*TextDeviceNode
2187 USB_CLASS_TEXT UsbClassText
;
2189 UsbClassText
.ClassExist
= FALSE
;
2190 UsbClassText
.Class
= USB_CLASS_RESERVE
;
2191 UsbClassText
.SubClassExist
= FALSE
;
2192 UsbClassText
.SubClass
= USB_SUBCLASS_IRDA_BRIDGE
;
2194 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
2198 Converts a text device path node to USB text and measurement device path structure.
2200 @param TextDeviceNode The input Text device path node.
2202 @return A pointer to the newly-created USB text and measurement device path structure.
2205 EFI_DEVICE_PATH_PROTOCOL
*
2206 DevPathFromTextUsbTestAndMeasurement (
2207 IN CHAR16
*TextDeviceNode
2210 USB_CLASS_TEXT UsbClassText
;
2212 UsbClassText
.ClassExist
= FALSE
;
2213 UsbClassText
.Class
= USB_CLASS_RESERVE
;
2214 UsbClassText
.SubClassExist
= FALSE
;
2215 UsbClassText
.SubClass
= USB_SUBCLASS_TEST
;
2217 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
2221 Converts a text device path node to USB WWID device path structure.
2223 @param TextDeviceNode The input Text device path node.
2225 @return A pointer to the newly-created USB WWID device path structure.
2228 EFI_DEVICE_PATH_PROTOCOL
*
2229 DevPathFromTextUsbWwid (
2230 IN CHAR16
*TextDeviceNode
2235 CHAR16
*InterfaceNumStr
;
2236 CHAR16
*SerialNumberStr
;
2237 USB_WWID_DEVICE_PATH
*UsbWwid
;
2239 VIDStr
= GetNextParamStr (&TextDeviceNode
);
2240 PIDStr
= GetNextParamStr (&TextDeviceNode
);
2241 InterfaceNumStr
= GetNextParamStr (&TextDeviceNode
);
2242 SerialNumberStr
= GetNextParamStr (&TextDeviceNode
);
2243 UsbWwid
= (USB_WWID_DEVICE_PATH
*) CreateDeviceNode (
2244 MESSAGING_DEVICE_PATH
,
2246 (UINT16
) (sizeof (USB_WWID_DEVICE_PATH
) + StrSize (SerialNumberStr
))
2249 UsbWwid
->VendorId
= (UINT16
) Strtoi (VIDStr
);
2250 UsbWwid
->ProductId
= (UINT16
) Strtoi (PIDStr
);
2251 UsbWwid
->InterfaceNumber
= (UINT16
) Strtoi (InterfaceNumStr
);
2252 StrCpy ((CHAR16
*) ((UINT8
*) UsbWwid
+ sizeof (USB_WWID_DEVICE_PATH
)), SerialNumberStr
);
2254 return (EFI_DEVICE_PATH_PROTOCOL
*) UsbWwid
;
2258 Converts a text device path node to Logic Unit device path structure.
2260 @param TextDeviceNode The input Text device path node.
2262 @return A pointer to the newly-created Logic Unit device path structure.
2265 EFI_DEVICE_PATH_PROTOCOL
*
2266 DevPathFromTextUnit (
2267 IN CHAR16
*TextDeviceNode
2271 DEVICE_LOGICAL_UNIT_DEVICE_PATH
*LogicalUnit
;
2273 LunStr
= GetNextParamStr (&TextDeviceNode
);
2274 LogicalUnit
= (DEVICE_LOGICAL_UNIT_DEVICE_PATH
*) CreateDeviceNode (
2275 MESSAGING_DEVICE_PATH
,
2276 MSG_DEVICE_LOGICAL_UNIT_DP
,
2277 (UINT16
) sizeof (DEVICE_LOGICAL_UNIT_DEVICE_PATH
)
2280 LogicalUnit
->Lun
= (UINT8
) Strtoi (LunStr
);
2282 return (EFI_DEVICE_PATH_PROTOCOL
*) LogicalUnit
;
2286 Converts a text device path node to iSCSI device path structure.
2288 @param TextDeviceNode The input Text device path node.
2290 @return A pointer to the newly-created iSCSI device path structure.
2293 EFI_DEVICE_PATH_PROTOCOL
*
2294 DevPathFromTextiSCSI (
2295 IN CHAR16
*TextDeviceNode
2300 CHAR16
*PortalGroupStr
;
2302 CHAR16
*HeaderDigestStr
;
2303 CHAR16
*DataDigestStr
;
2304 CHAR16
*AuthenticationStr
;
2305 CHAR16
*ProtocolStr
;
2307 ISCSI_DEVICE_PATH_WITH_NAME
*ISCSIDevPath
;
2309 NameStr
= GetNextParamStr (&TextDeviceNode
);
2310 PortalGroupStr
= GetNextParamStr (&TextDeviceNode
);
2311 LunStr
= GetNextParamStr (&TextDeviceNode
);
2312 HeaderDigestStr
= GetNextParamStr (&TextDeviceNode
);
2313 DataDigestStr
= GetNextParamStr (&TextDeviceNode
);
2314 AuthenticationStr
= GetNextParamStr (&TextDeviceNode
);
2315 ProtocolStr
= GetNextParamStr (&TextDeviceNode
);
2316 ISCSIDevPath
= (ISCSI_DEVICE_PATH_WITH_NAME
*) CreateDeviceNode (
2317 MESSAGING_DEVICE_PATH
,
2319 (UINT16
) (sizeof (ISCSI_DEVICE_PATH_WITH_NAME
) + StrLen (NameStr
))
2322 AsciiStr
= ISCSIDevPath
->iSCSITargetName
;
2323 StrToAscii (NameStr
, &AsciiStr
);
2325 ISCSIDevPath
->TargetPortalGroupTag
= (UINT16
) Strtoi (PortalGroupStr
);
2326 Strtoi64 (LunStr
, &ISCSIDevPath
->Lun
);
2329 if (StrCmp (HeaderDigestStr
, L
"CRC32C") == 0) {
2333 if (StrCmp (DataDigestStr
, L
"CRC32C") == 0) {
2337 if (StrCmp (AuthenticationStr
, L
"None") == 0) {
2341 if (StrCmp (AuthenticationStr
, L
"CHAP_UNI") == 0) {
2345 ISCSIDevPath
->LoginOption
= (UINT16
) Options
;
2347 ISCSIDevPath
->NetworkProtocol
= (UINT16
) StrCmp (ProtocolStr
, L
"TCP");
2349 return (EFI_DEVICE_PATH_PROTOCOL
*) ISCSIDevPath
;
2353 Converts a text device path node to HD device path structure.
2355 @param TextDeviceNode The input Text device path node.
2357 @return A pointer to the newly-created HD device path structure.
2360 EFI_DEVICE_PATH_PROTOCOL
*
2362 IN CHAR16
*TextDeviceNode
2365 CHAR16
*PartitionStr
;
2367 CHAR16
*SignatureStr
;
2371 EFI_GUID SignatureGuid
;
2372 HARDDRIVE_DEVICE_PATH
*Hd
;
2374 PartitionStr
= GetNextParamStr (&TextDeviceNode
);
2375 TypeStr
= GetNextParamStr (&TextDeviceNode
);
2376 SignatureStr
= GetNextParamStr (&TextDeviceNode
);
2377 StartStr
= GetNextParamStr (&TextDeviceNode
);
2378 SizeStr
= GetNextParamStr (&TextDeviceNode
);
2379 Hd
= (HARDDRIVE_DEVICE_PATH
*) CreateDeviceNode (
2382 sizeof (HARDDRIVE_DEVICE_PATH
)
2385 Hd
->PartitionNumber
= (UINT32
) Dtoi (PartitionStr
);
2387 ZeroMem (Hd
->Signature
, 16);
2388 Hd
->MBRType
= (UINT8
) 0;
2390 if (StrCmp (TypeStr
, L
"MBR") == 0) {
2391 Hd
->SignatureType
= SIGNATURE_TYPE_MBR
;
2394 Signature32
= (UINT32
) Strtoi (SignatureStr
);
2395 CopyMem (Hd
->Signature
, &Signature32
, sizeof (UINT32
));
2396 } else if (StrCmp (TypeStr
, L
"GPT") == 0) {
2397 Hd
->SignatureType
= SIGNATURE_TYPE_GUID
;
2400 StrToGuid (SignatureStr
, &SignatureGuid
);
2401 CopyMem (Hd
->Signature
, &SignatureGuid
, sizeof (EFI_GUID
));
2403 Hd
->SignatureType
= (UINT8
) Strtoi (TypeStr
);
2406 Strtoi64 (StartStr
, &Hd
->PartitionStart
);
2407 Strtoi64 (SizeStr
, &Hd
->PartitionSize
);
2409 return (EFI_DEVICE_PATH_PROTOCOL
*) Hd
;
2413 Converts a text device path node to CDROM device path structure.
2415 @param TextDeviceNode The input Text device path node.
2417 @return A pointer to the newly-created CDROM device path structure.
2420 EFI_DEVICE_PATH_PROTOCOL
*
2421 DevPathFromTextCDROM (
2422 IN CHAR16
*TextDeviceNode
2428 CDROM_DEVICE_PATH
*CDROMDevPath
;
2430 EntryStr
= GetNextParamStr (&TextDeviceNode
);
2431 StartStr
= GetNextParamStr (&TextDeviceNode
);
2432 SizeStr
= GetNextParamStr (&TextDeviceNode
);
2433 CDROMDevPath
= (CDROM_DEVICE_PATH
*) CreateDeviceNode (
2436 sizeof (CDROM_DEVICE_PATH
)
2439 CDROMDevPath
->BootEntry
= (UINT32
) Strtoi (EntryStr
);
2440 Strtoi64 (StartStr
, &CDROMDevPath
->PartitionStart
);
2441 Strtoi64 (SizeStr
, &CDROMDevPath
->PartitionSize
);
2443 return (EFI_DEVICE_PATH_PROTOCOL
*) CDROMDevPath
;
2447 Converts a text device path node to Vendor-defined media device path structure.
2449 @param TextDeviceNode The input Text device path node.
2451 @return A pointer to the newly-created Vendor-defined media device path structure.
2454 EFI_DEVICE_PATH_PROTOCOL
*
2455 DevPathFromTextVenMEDIA (
2456 IN CHAR16
*TextDeviceNode
2459 return ConvertFromTextVendor (
2467 Converts a text device path node to File device path structure.
2469 @param TextDeviceNode The input Text device path node.
2471 @return A pointer to the newly-created File device path structure.
2474 EFI_DEVICE_PATH_PROTOCOL
*
2475 DevPathFromTextFilePath (
2476 IN CHAR16
*TextDeviceNode
2479 FILEPATH_DEVICE_PATH
*File
;
2481 File
= (FILEPATH_DEVICE_PATH
*) CreateDeviceNode (
2484 (UINT16
) (sizeof (FILEPATH_DEVICE_PATH
) + StrLen (TextDeviceNode
) * 2)
2487 StrCpy (File
->PathName
, TextDeviceNode
);
2489 return (EFI_DEVICE_PATH_PROTOCOL
*) File
;
2493 Converts a text device path node to Media protocol device path structure.
2495 @param TextDeviceNode The input Text device path node.
2497 @return A pointer to the newly-created Media protocol device path structure.
2500 EFI_DEVICE_PATH_PROTOCOL
*
2501 DevPathFromTextMedia (
2502 IN CHAR16
*TextDeviceNode
2506 MEDIA_PROTOCOL_DEVICE_PATH
*Media
;
2508 GuidStr
= GetNextParamStr (&TextDeviceNode
);
2509 Media
= (MEDIA_PROTOCOL_DEVICE_PATH
*) CreateDeviceNode (
2512 sizeof (MEDIA_PROTOCOL_DEVICE_PATH
)
2515 StrToGuid (GuidStr
, &Media
->Protocol
);
2517 return (EFI_DEVICE_PATH_PROTOCOL
*) Media
;
2521 Converts a text device path node to firmware volume device path structure.
2523 @param TextDeviceNode The input Text device path node.
2525 @return A pointer to the newly-created firmware volume device path structure.
2528 EFI_DEVICE_PATH_PROTOCOL
*
2530 IN CHAR16
*TextDeviceNode
2534 MEDIA_FW_VOL_DEVICE_PATH
*Fv
;
2536 GuidStr
= GetNextParamStr (&TextDeviceNode
);
2537 Fv
= (MEDIA_FW_VOL_DEVICE_PATH
*) CreateDeviceNode (
2539 MEDIA_PIWG_FW_VOL_DP
,
2540 sizeof (MEDIA_FW_VOL_DEVICE_PATH
)
2543 StrToGuid (GuidStr
, &Fv
->FvName
);
2545 return (EFI_DEVICE_PATH_PROTOCOL
*) Fv
;
2549 Converts a text device path node to firmware file device path structure.
2551 @param TextDeviceNode The input Text device path node.
2553 @return A pointer to the newly-created firmware file device path structure.
2556 EFI_DEVICE_PATH_PROTOCOL
*
2557 DevPathFromTextFvFile (
2558 IN CHAR16
*TextDeviceNode
2562 MEDIA_FW_VOL_FILEPATH_DEVICE_PATH
*FvFile
;
2564 GuidStr
= GetNextParamStr (&TextDeviceNode
);
2565 FvFile
= (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH
*) CreateDeviceNode (
2567 MEDIA_PIWG_FW_FILE_DP
,
2568 sizeof (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH
)
2571 StrToGuid (GuidStr
, &FvFile
->FvFileName
);
2573 return (EFI_DEVICE_PATH_PROTOCOL
*) FvFile
;
2577 Converts a text device path node to BIOS Boot Specification device path structure.
2579 @param TextDeviceNode The input Text device path node.
2581 @return A pointer to the newly-created BIOS Boot Specificationa device path structure.
2584 EFI_DEVICE_PATH_PROTOCOL
*
2585 DevPathFromTextBBS (
2586 IN CHAR16
*TextDeviceNode
2593 BBS_BBS_DEVICE_PATH
*Bbs
;
2595 TypeStr
= GetNextParamStr (&TextDeviceNode
);
2596 IdStr
= GetNextParamStr (&TextDeviceNode
);
2597 FlagsStr
= GetNextParamStr (&TextDeviceNode
);
2598 Bbs
= (BBS_BBS_DEVICE_PATH
*) CreateDeviceNode (
2601 (UINT16
) (sizeof (BBS_BBS_DEVICE_PATH
) + StrLen (IdStr
))
2604 if (StrCmp (TypeStr
, L
"Floppy") == 0) {
2605 Bbs
->DeviceType
= BBS_TYPE_FLOPPY
;
2606 } else if (StrCmp (TypeStr
, L
"HD") == 0) {
2607 Bbs
->DeviceType
= BBS_TYPE_HARDDRIVE
;
2608 } else if (StrCmp (TypeStr
, L
"CDROM") == 0) {
2609 Bbs
->DeviceType
= BBS_TYPE_CDROM
;
2610 } else if (StrCmp (TypeStr
, L
"PCMCIA") == 0) {
2611 Bbs
->DeviceType
= BBS_TYPE_PCMCIA
;
2612 } else if (StrCmp (TypeStr
, L
"USB") == 0) {
2613 Bbs
->DeviceType
= BBS_TYPE_USB
;
2614 } else if (StrCmp (TypeStr
, L
"Network") == 0) {
2615 Bbs
->DeviceType
= BBS_TYPE_EMBEDDED_NETWORK
;
2617 Bbs
->DeviceType
= (UINT16
) Strtoi (TypeStr
);
2620 AsciiStr
= Bbs
->String
;
2621 StrToAscii (IdStr
, &AsciiStr
);
2623 Bbs
->StatusFlag
= (UINT16
) Strtoi (FlagsStr
);
2625 return (EFI_DEVICE_PATH_PROTOCOL
*) Bbs
;
2629 Converts a text device path node to SATA device path structure.
2631 @param TextDeviceNode The input Text device path node.
2633 @return A pointer to the newly-created SATA device path structure.
2636 EFI_DEVICE_PATH_PROTOCOL
*
2637 DevPathFromTextSata (
2638 IN CHAR16
*TextDeviceNode
2641 SATA_DEVICE_PATH
*Sata
;
2647 // The PMPN is optional.
2649 Param1
= GetNextParamStr (&TextDeviceNode
);
2650 Param2
= GetNextParamStr (&TextDeviceNode
);
2652 if (!IS_NULL (TextDeviceNode
)) {
2653 Param3
= GetNextParamStr (&TextDeviceNode
);
2656 Sata
= (SATA_DEVICE_PATH
*) CreateDeviceNode (
2657 MESSAGING_DEVICE_PATH
,
2659 sizeof (SATA_DEVICE_PATH
)
2661 Sata
->HBAPortNumber
= (UINT16
) Xtoi (Param1
);
2662 if (Param3
!= NULL
) {
2663 Sata
->PortMultiplierPortNumber
= (UINT16
) Xtoi (Param2
);
2666 Sata
->PortMultiplierPortNumber
= 0;
2668 Sata
->Lun
= (UINT16
) Xtoi (Param2
);
2670 return (EFI_DEVICE_PATH_PROTOCOL
*) Sata
;
2673 GLOBAL_REMOVE_IF_UNREFERENCED DEVICE_PATH_FROM_TEXT_TABLE DevPathFromTextTable
[] = {
2674 {L
"Pci", DevPathFromTextPci
},
2675 {L
"PcCard", DevPathFromTextPcCard
},
2676 {L
"MemoryMapped", DevPathFromTextMemoryMapped
},
2677 {L
"VenHw", DevPathFromTextVenHw
},
2678 {L
"Ctrl", DevPathFromTextCtrl
},
2679 {L
"Acpi", DevPathFromTextAcpi
},
2680 {L
"PciRoot", DevPathFromTextPciRoot
},
2681 {L
"Floppy", DevPathFromTextFloppy
},
2682 {L
"Keyboard", DevPathFromTextKeyboard
},
2683 {L
"Serial", DevPathFromTextSerial
},
2684 {L
"ParallelPort", DevPathFromTextParallelPort
},
2685 {L
"AcpiEx", DevPathFromTextAcpiEx
},
2686 {L
"AcpiExp", DevPathFromTextAcpiExp
},
2687 {L
"Ata", DevPathFromTextAta
},
2688 {L
"Scsi", DevPathFromTextScsi
},
2689 {L
"Fibre", DevPathFromTextFibre
},
2690 {L
"I1394", DevPathFromText1394
},
2691 {L
"USB", DevPathFromTextUsb
},
2692 {L
"I2O", DevPathFromTextI2O
},
2693 {L
"Infiniband", DevPathFromTextInfiniband
},
2694 {L
"VenMsg", DevPathFromTextVenMsg
},
2695 {L
"VenPcAnsi", DevPathFromTextVenPcAnsi
},
2696 {L
"VenVt100", DevPathFromTextVenVt100
},
2697 {L
"VenVt100Plus", DevPathFromTextVenVt100Plus
},
2698 {L
"VenUtf8", DevPathFromTextVenUtf8
},
2699 {L
"UartFlowCtrl", DevPathFromTextUartFlowCtrl
},
2700 {L
"SAS", DevPathFromTextSAS
},
2701 {L
"DebugPort", DevPathFromTextDebugPort
},
2702 {L
"MAC", DevPathFromTextMAC
},
2703 {L
"IPv4", DevPathFromTextIPv4
},
2704 {L
"IPv6", DevPathFromTextIPv6
},
2705 {L
"Uart", DevPathFromTextUart
},
2706 {L
"UsbClass", DevPathFromTextUsbClass
},
2707 {L
"UsbAudio", DevPathFromTextUsbAudio
},
2708 {L
"UsbCDCControl", DevPathFromTextUsbCDCControl
},
2709 {L
"UsbHID", DevPathFromTextUsbHID
},
2710 {L
"UsbImage", DevPathFromTextUsbImage
},
2711 {L
"UsbPrinter", DevPathFromTextUsbPrinter
},
2712 {L
"UsbMassStorage", DevPathFromTextUsbMassStorage
},
2713 {L
"UsbHub", DevPathFromTextUsbHub
},
2714 {L
"UsbCDCData", DevPathFromTextUsbCDCData
},
2715 {L
"UsbSmartCard", DevPathFromTextUsbSmartCard
},
2716 {L
"UsbVideo", DevPathFromTextUsbVideo
},
2717 {L
"UsbDiagnostic", DevPathFromTextUsbDiagnostic
},
2718 {L
"UsbWireless", DevPathFromTextUsbWireless
},
2719 {L
"UsbDeviceFirmwareUpdate", DevPathFromTextUsbDeviceFirmwareUpdate
},
2720 {L
"UsbIrdaBridge", DevPathFromTextUsbIrdaBridge
},
2721 {L
"UsbTestAndMeasurement", DevPathFromTextUsbTestAndMeasurement
},
2722 {L
"UsbWwid", DevPathFromTextUsbWwid
},
2723 {L
"Unit", DevPathFromTextUnit
},
2724 {L
"iSCSI", DevPathFromTextiSCSI
},
2725 {L
"HD", DevPathFromTextHD
},
2726 {L
"CDROM", DevPathFromTextCDROM
},
2727 {L
"VenMEDIA", DevPathFromTextVenMEDIA
},
2728 {L
"Media", DevPathFromTextMedia
},
2729 {L
"Fv", DevPathFromTextFv
},
2730 {L
"FvFile", DevPathFromTextFvFile
},
2731 {L
"BBS", DevPathFromTextBBS
},
2732 {L
"Sata", DevPathFromTextSata
},
2737 Convert text to the binary representation of a device node.
2739 @param TextDeviceNode TextDeviceNode points to the text representation of a device
2740 node. Conversion starts with the first character and continues
2741 until the first non-device node character.
2743 @return A pointer to the EFI device node or NULL if TextDeviceNode is NULL or there was
2744 insufficient memory or text unsupported.
2747 EFI_DEVICE_PATH_PROTOCOL
*
2749 ConvertTextToDeviceNode (
2750 IN CONST CHAR16
*TextDeviceNode
2755 EFI_DEVICE_PATH_PROTOCOL
*DeviceNode
;
2756 CHAR16
*DeviceNodeStr
;
2759 if ((TextDeviceNode
== NULL
) || (IS_NULL (*TextDeviceNode
))) {
2765 DeviceNodeStr
= StrDuplicate (TextDeviceNode
);
2766 ASSERT (DeviceNodeStr
!= NULL
);
2768 for (Index
= 0; DevPathFromTextTable
[Index
].Function
!= NULL
; Index
++) {
2769 ParamStr
= GetParamByNodeName (DeviceNodeStr
, DevPathFromTextTable
[Index
].DevicePathNodeText
);
2770 if (ParamStr
!= NULL
) {
2771 DumpNode
= DevPathFromTextTable
[Index
].Function
;
2776 if (DumpNode
== NULL
) {
2780 DumpNode
= DevPathFromTextFilePath
;
2781 DeviceNode
= DumpNode (DeviceNodeStr
);
2783 DeviceNode
= DumpNode (ParamStr
);
2784 FreePool (ParamStr
);
2787 FreePool (DeviceNodeStr
);
2793 Convert text to the binary representation of a device path.
2796 @param TextDevicePath TextDevicePath points to the text representation of a device
2797 path. Conversion starts with the first character and continues
2798 until the first non-device node character.
2800 @return A pointer to the allocated device path or NULL if TextDeviceNode is NULL or
2801 there was insufficient memory.
2804 EFI_DEVICE_PATH_PROTOCOL
*
2806 ConvertTextToDevicePath (
2807 IN CONST CHAR16
*TextDevicePath
2812 EFI_DEVICE_PATH_PROTOCOL
*DeviceNode
;
2814 EFI_DEVICE_PATH_PROTOCOL
*NewDevicePath
;
2815 CHAR16
*DevicePathStr
;
2817 CHAR16
*DeviceNodeStr
;
2818 UINT8 IsInstanceEnd
;
2819 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
2821 if ((TextDevicePath
== NULL
) || (IS_NULL (*TextDevicePath
))) {
2825 DevicePath
= (EFI_DEVICE_PATH_PROTOCOL
*) AllocatePool (END_DEVICE_PATH_LENGTH
);
2826 ASSERT (DevicePath
!= NULL
);
2827 SetDevicePathEndNode (DevicePath
);
2830 DeviceNodeStr
= NULL
;
2831 DevicePathStr
= StrDuplicate (TextDevicePath
);
2833 Str
= DevicePathStr
;
2834 while ((DeviceNodeStr
= GetNextDeviceNodeStr (&Str
, &IsInstanceEnd
)) != NULL
) {
2836 for (Index
= 0; DevPathFromTextTable
[Index
].Function
!= NULL
; Index
++) {
2837 ParamStr
= GetParamByNodeName (DeviceNodeStr
, DevPathFromTextTable
[Index
].DevicePathNodeText
);
2838 if (ParamStr
!= NULL
) {
2839 DumpNode
= DevPathFromTextTable
[Index
].Function
;
2844 if (DumpNode
== NULL
) {
2848 DumpNode
= DevPathFromTextFilePath
;
2849 DeviceNode
= DumpNode (DeviceNodeStr
);
2851 DeviceNode
= DumpNode (ParamStr
);
2852 FreePool (ParamStr
);
2855 NewDevicePath
= AppendDeviceNodeProtocolInterface (DevicePath
, DeviceNode
);
2856 FreePool (DevicePath
);
2857 FreePool (DeviceNode
);
2858 DevicePath
= NewDevicePath
;
2860 if (IsInstanceEnd
!= 0) {
2861 DeviceNode
= (EFI_DEVICE_PATH_PROTOCOL
*) AllocatePool (END_DEVICE_PATH_LENGTH
);
2862 ASSERT (DeviceNode
!= NULL
);
2863 SET_DEVICE_PATH_INSTANCE_END_NODE (DeviceNode
);
2865 NewDevicePath
= AppendDeviceNodeProtocolInterface (DevicePath
, DeviceNode
);
2866 FreePool (DevicePath
);
2867 FreePool (DeviceNode
);
2868 DevicePath
= NewDevicePath
;
2872 FreePool (DevicePathStr
);