2 DevicePathFromText protocol as defined in the UEFI 2.0 specification.
4 Copyright (c) 2013 - 2017, Intel Corporation. All rights reserved.<BR>
5 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 "UefiDevicePathLib.h"
21 @param Src Source string.
23 @return The duplicated string.
27 UefiDevicePathLibStrDuplicate (
31 return AllocateCopyPool (StrSize (Src
), Src
);
36 Get parameter in a pair of parentheses follow the given node name.
37 For example, given the "Pci(0,1)" and NodeName "Pci", it returns "0,1".
39 @param Str Device Path Text.
40 @param NodeName Name of the node.
42 @return Parameter text for the node.
54 UINTN ParameterLength
;
57 // Check whether the node name matchs
59 NodeNameLength
= StrLen (NodeName
);
60 if (StrnCmp (Str
, NodeName
, NodeNameLength
) != 0) {
64 ParamStr
= Str
+ NodeNameLength
;
65 if (!IS_LEFT_PARENTH (*ParamStr
)) {
70 // Skip the found '(' and find first occurrence of ')'
74 StrPointer
= ParamStr
;
75 while (!IS_NULL (*StrPointer
)) {
76 if (IS_RIGHT_PARENTH (*StrPointer
)) {
82 if (IS_NULL (*StrPointer
)) {
89 ParamStr
= AllocateCopyPool ((ParameterLength
+ 1) * sizeof (CHAR16
), ParamStr
);
90 if (ParamStr
== NULL
) {
94 // Terminate the parameter string
96 ParamStr
[ParameterLength
] = L
'\0';
102 Gets current sub-string from a string list, before return
103 the list header is moved to next sub-string. The sub-string is separated
104 by the specified character. For example, the separator is ',', the string
105 list is "2,0,3", it returns "2", the remain list move to "0,3"
107 @param List A string list separated by the specified separator
108 @param Separator The separator character
110 @return A pointer to the current sub-string
115 IN OUT CHAR16
**List
,
125 if (IS_NULL (*Str
)) {
130 // Find first occurrence of the separator
132 while (!IS_NULL (*Str
)) {
133 if (*Str
== Separator
) {
139 if (*Str
== Separator
) {
141 // Find a sub-string, terminate it
148 // Move to next sub-string
156 Gets the next parameter string from the list.
158 @param List A string list separated by the specified separator
160 @return A pointer to the current sub-string
169 // The separator is comma
171 return SplitStr (List
, L
',');
175 Get one device node from entire device path text.
177 @param DevicePath On input, the current Device Path node; on output, the next device path node
178 @param IsInstanceEnd This node is the end of a device path instance
180 @return A device node text or NULL if no more device node available
184 GetNextDeviceNodeStr (
185 IN OUT CHAR16
**DevicePath
,
186 OUT BOOLEAN
*IsInstanceEnd
191 UINTN ParenthesesStack
;
194 if (IS_NULL (*Str
)) {
199 // Skip the leading '/', '(', ')' and ','
201 while (!IS_NULL (*Str
)) {
202 if (!IS_SLASH (*Str
) &&
204 !IS_LEFT_PARENTH (*Str
) &&
205 !IS_RIGHT_PARENTH (*Str
)) {
214 // Scan for the separator of this device node, '/' or ','
216 ParenthesesStack
= 0;
217 while (!IS_NULL (*Str
)) {
218 if ((IS_COMMA (*Str
) || IS_SLASH (*Str
)) && (ParenthesesStack
== 0)) {
222 if (IS_LEFT_PARENTH (*Str
)) {
224 } else if (IS_RIGHT_PARENTH (*Str
)) {
231 if (ParenthesesStack
!= 0) {
233 // The '(' doesn't pair with ')', invalid device path text
238 if (IS_COMMA (*Str
)) {
239 *IsInstanceEnd
= TRUE
;
243 *IsInstanceEnd
= FALSE
;
244 if (!IS_NULL (*Str
)) {
257 Return whether the integer string is a hex string.
259 @param Str The integer string
261 @retval TRUE Hex string
262 @retval FALSE Decimal string
271 // skip preceeding white space
273 while ((*Str
!= 0) && *Str
== L
' ') {
277 // skip preceeding zeros
279 while ((*Str
!= 0) && *Str
== L
'0') {
283 return (BOOLEAN
) (*Str
== L
'x' || *Str
== L
'X');
288 Convert integer string to uint.
290 @param Str The integer string. If leading with "0x" or "0X", it's hexadecimal.
292 @return A UINTN value represented by Str
300 if (IsHexStr (Str
)) {
301 return StrHexToUintn (Str
);
303 return StrDecimalToUintn (Str
);
309 Convert integer string to 64 bit data.
311 @param Str The integer string. If leading with "0x" or "0X", it's hexadecimal.
312 @param Data A pointer to the UINT64 value represented by Str
321 if (IsHexStr (Str
)) {
322 *Data
= StrHexToUint64 (Str
);
324 *Data
= StrDecimalToUint64 (Str
);
329 Converts a Unicode string to ASCII string.
331 @param Str The equivalent Unicode string
332 @param AsciiStr On input, it points to destination ASCII string buffer; on output, it points
333 to the next ASCII string next to it
339 IN OUT CHAR8
**AsciiStr
345 while (!IS_NULL (*Str
)) {
346 *(Dest
++) = (CHAR8
) *(Str
++);
351 // Return the string next to it
353 *AsciiStr
= Dest
+ 1;
357 Converts a generic text device path node to device path structure.
359 @param Type The type of the device path node.
360 @param TextDeviceNode The input text device path node.
362 @return A pointer to device path structure.
364 EFI_DEVICE_PATH_PROTOCOL
*
365 DevPathFromTextGenericPath (
367 IN CHAR16
*TextDeviceNode
370 EFI_DEVICE_PATH_PROTOCOL
*Node
;
375 SubtypeStr
= GetNextParamStr (&TextDeviceNode
);
376 DataStr
= GetNextParamStr (&TextDeviceNode
);
378 if (DataStr
== NULL
) {
381 DataLength
= StrLen (DataStr
) / 2;
383 Node
= CreateDeviceNode (
385 (UINT8
) Strtoi (SubtypeStr
),
386 (UINT16
) (sizeof (EFI_DEVICE_PATH_PROTOCOL
) + DataLength
)
389 StrHexToBytes (DataStr
, DataLength
* 2, (UINT8
*) (Node
+ 1), DataLength
);
394 Converts a generic text device path node to device path structure.
396 @param TextDeviceNode The input Text device path node.
398 @return A pointer to device path structure.
401 EFI_DEVICE_PATH_PROTOCOL
*
402 DevPathFromTextPath (
403 IN CHAR16
*TextDeviceNode
408 TypeStr
= GetNextParamStr (&TextDeviceNode
);
410 return DevPathFromTextGenericPath ((UINT8
) Strtoi (TypeStr
), TextDeviceNode
);
414 Converts a generic hardware text device path node to Hardware device path structure.
416 @param TextDeviceNode The input Text device path node.
418 @return A pointer to Hardware device path structure.
421 EFI_DEVICE_PATH_PROTOCOL
*
422 DevPathFromTextHardwarePath (
423 IN CHAR16
*TextDeviceNode
426 return DevPathFromTextGenericPath (HARDWARE_DEVICE_PATH
, TextDeviceNode
);
430 Converts a text device path node to Hardware PCI device path structure.
432 @param TextDeviceNode The input Text device path node.
434 @return A pointer to Hardware PCI device path structure.
437 EFI_DEVICE_PATH_PROTOCOL
*
439 IN CHAR16
*TextDeviceNode
444 PCI_DEVICE_PATH
*Pci
;
446 DeviceStr
= GetNextParamStr (&TextDeviceNode
);
447 FunctionStr
= GetNextParamStr (&TextDeviceNode
);
448 Pci
= (PCI_DEVICE_PATH
*) CreateDeviceNode (
449 HARDWARE_DEVICE_PATH
,
451 (UINT16
) sizeof (PCI_DEVICE_PATH
)
454 Pci
->Function
= (UINT8
) Strtoi (FunctionStr
);
455 Pci
->Device
= (UINT8
) Strtoi (DeviceStr
);
457 return (EFI_DEVICE_PATH_PROTOCOL
*) Pci
;
461 Converts a text device path node to Hardware PC card device path structure.
463 @param TextDeviceNode The input Text device path node.
465 @return A pointer to Hardware PC card device path structure.
468 EFI_DEVICE_PATH_PROTOCOL
*
469 DevPathFromTextPcCard (
470 IN CHAR16
*TextDeviceNode
473 CHAR16
*FunctionNumberStr
;
474 PCCARD_DEVICE_PATH
*Pccard
;
476 FunctionNumberStr
= GetNextParamStr (&TextDeviceNode
);
477 Pccard
= (PCCARD_DEVICE_PATH
*) CreateDeviceNode (
478 HARDWARE_DEVICE_PATH
,
480 (UINT16
) sizeof (PCCARD_DEVICE_PATH
)
483 Pccard
->FunctionNumber
= (UINT8
) Strtoi (FunctionNumberStr
);
485 return (EFI_DEVICE_PATH_PROTOCOL
*) Pccard
;
489 Converts a text device path node to Hardware memory map device path structure.
491 @param TextDeviceNode The input Text device path node.
493 @return A pointer to Hardware memory map device path structure.
496 EFI_DEVICE_PATH_PROTOCOL
*
497 DevPathFromTextMemoryMapped (
498 IN CHAR16
*TextDeviceNode
501 CHAR16
*MemoryTypeStr
;
502 CHAR16
*StartingAddressStr
;
503 CHAR16
*EndingAddressStr
;
504 MEMMAP_DEVICE_PATH
*MemMap
;
506 MemoryTypeStr
= GetNextParamStr (&TextDeviceNode
);
507 StartingAddressStr
= GetNextParamStr (&TextDeviceNode
);
508 EndingAddressStr
= GetNextParamStr (&TextDeviceNode
);
509 MemMap
= (MEMMAP_DEVICE_PATH
*) CreateDeviceNode (
510 HARDWARE_DEVICE_PATH
,
512 (UINT16
) sizeof (MEMMAP_DEVICE_PATH
)
515 MemMap
->MemoryType
= (UINT32
) Strtoi (MemoryTypeStr
);
516 Strtoi64 (StartingAddressStr
, &MemMap
->StartingAddress
);
517 Strtoi64 (EndingAddressStr
, &MemMap
->EndingAddress
);
519 return (EFI_DEVICE_PATH_PROTOCOL
*) MemMap
;
523 Converts a text device path node to Vendor device path structure based on the input Type
526 @param TextDeviceNode The input Text device path node.
527 @param Type The type of device path node.
528 @param SubType The subtype of device path node.
530 @return A pointer to the newly-created Vendor device path structure.
533 EFI_DEVICE_PATH_PROTOCOL
*
534 ConvertFromTextVendor (
535 IN CHAR16
*TextDeviceNode
,
543 VENDOR_DEVICE_PATH
*Vendor
;
545 GuidStr
= GetNextParamStr (&TextDeviceNode
);
547 DataStr
= GetNextParamStr (&TextDeviceNode
);
548 Length
= StrLen (DataStr
);
550 // Two hex characters make up 1 buffer byte
552 Length
= (Length
+ 1) / 2;
554 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
557 (UINT16
) (sizeof (VENDOR_DEVICE_PATH
) + Length
)
560 StrToGuid (GuidStr
, &Vendor
->Guid
);
561 StrHexToBytes (DataStr
, Length
* 2, (UINT8
*) (Vendor
+ 1), Length
);
563 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
567 Converts a text device path node to Vendor Hardware device path structure.
569 @param TextDeviceNode The input Text device path node.
571 @return A pointer to the newly-created Vendor Hardware device path structure.
574 EFI_DEVICE_PATH_PROTOCOL
*
575 DevPathFromTextVenHw (
576 IN CHAR16
*TextDeviceNode
579 return ConvertFromTextVendor (
581 HARDWARE_DEVICE_PATH
,
587 Converts a text device path node to Hardware Controller device path structure.
589 @param TextDeviceNode The input Text device path node.
591 @return A pointer to the newly-created Hardware Controller device path structure.
594 EFI_DEVICE_PATH_PROTOCOL
*
595 DevPathFromTextCtrl (
596 IN CHAR16
*TextDeviceNode
599 CHAR16
*ControllerStr
;
600 CONTROLLER_DEVICE_PATH
*Controller
;
602 ControllerStr
= GetNextParamStr (&TextDeviceNode
);
603 Controller
= (CONTROLLER_DEVICE_PATH
*) CreateDeviceNode (
604 HARDWARE_DEVICE_PATH
,
606 (UINT16
) sizeof (CONTROLLER_DEVICE_PATH
)
608 Controller
->ControllerNumber
= (UINT32
) Strtoi (ControllerStr
);
610 return (EFI_DEVICE_PATH_PROTOCOL
*) Controller
;
614 Converts a text device path node to BMC device path structure.
616 @param TextDeviceNode The input Text device path node.
618 @return A pointer to the newly-created BMC device path structure.
621 EFI_DEVICE_PATH_PROTOCOL
*
623 IN CHAR16
*TextDeviceNode
626 CHAR16
*InterfaceTypeStr
;
627 CHAR16
*BaseAddressStr
;
628 BMC_DEVICE_PATH
*BmcDp
;
630 InterfaceTypeStr
= GetNextParamStr (&TextDeviceNode
);
631 BaseAddressStr
= GetNextParamStr (&TextDeviceNode
);
632 BmcDp
= (BMC_DEVICE_PATH
*) CreateDeviceNode (
633 HARDWARE_DEVICE_PATH
,
635 (UINT16
) sizeof (BMC_DEVICE_PATH
)
638 BmcDp
->InterfaceType
= (UINT8
) Strtoi (InterfaceTypeStr
);
640 (UINT64
*) (&BmcDp
->BaseAddress
),
641 StrHexToUint64 (BaseAddressStr
)
644 return (EFI_DEVICE_PATH_PROTOCOL
*) BmcDp
;
648 Converts a generic ACPI text device path node to ACPI device path structure.
650 @param TextDeviceNode The input Text device path node.
652 @return A pointer to ACPI device path structure.
655 EFI_DEVICE_PATH_PROTOCOL
*
656 DevPathFromTextAcpiPath (
657 IN CHAR16
*TextDeviceNode
660 return DevPathFromTextGenericPath (ACPI_DEVICE_PATH
, TextDeviceNode
);
664 Converts a string to EisaId.
666 @param Text The input string.
668 @return UINT32 EISA ID.
675 return (((Text
[0] - 'A' + 1) & 0x1f) << 10)
676 + (((Text
[1] - 'A' + 1) & 0x1f) << 5)
677 + (((Text
[2] - 'A' + 1) & 0x1f) << 0)
678 + (UINT32
) (StrHexToUintn (&Text
[3]) << 16)
683 Converts a text device path node to ACPI HID device path structure.
685 @param TextDeviceNode The input Text device path node.
687 @return A pointer to the newly-created ACPI HID device path structure.
690 EFI_DEVICE_PATH_PROTOCOL
*
691 DevPathFromTextAcpi (
692 IN CHAR16
*TextDeviceNode
697 ACPI_HID_DEVICE_PATH
*Acpi
;
699 HIDStr
= GetNextParamStr (&TextDeviceNode
);
700 UIDStr
= GetNextParamStr (&TextDeviceNode
);
701 Acpi
= (ACPI_HID_DEVICE_PATH
*) CreateDeviceNode (
704 (UINT16
) sizeof (ACPI_HID_DEVICE_PATH
)
707 Acpi
->HID
= EisaIdFromText (HIDStr
);
708 Acpi
->UID
= (UINT32
) Strtoi (UIDStr
);
710 return (EFI_DEVICE_PATH_PROTOCOL
*) Acpi
;
714 Converts a text device path node to ACPI HID device path structure.
716 @param TextDeviceNode The input Text device path node.
717 @param PnPId The input plug and play identification.
719 @return A pointer to the newly-created ACPI HID device path structure.
722 EFI_DEVICE_PATH_PROTOCOL
*
723 ConvertFromTextAcpi (
724 IN CHAR16
*TextDeviceNode
,
729 ACPI_HID_DEVICE_PATH
*Acpi
;
731 UIDStr
= GetNextParamStr (&TextDeviceNode
);
732 Acpi
= (ACPI_HID_DEVICE_PATH
*) CreateDeviceNode (
735 (UINT16
) sizeof (ACPI_HID_DEVICE_PATH
)
738 Acpi
->HID
= EFI_PNP_ID (PnPId
);
739 Acpi
->UID
= (UINT32
) Strtoi (UIDStr
);
741 return (EFI_DEVICE_PATH_PROTOCOL
*) Acpi
;
745 Converts a text device path node to PCI root device path structure.
747 @param TextDeviceNode The input Text device path node.
749 @return A pointer to the newly-created PCI root device path structure.
752 EFI_DEVICE_PATH_PROTOCOL
*
753 DevPathFromTextPciRoot (
754 IN CHAR16
*TextDeviceNode
757 return ConvertFromTextAcpi (TextDeviceNode
, 0x0a03);
761 Converts a text device path node to PCIE root device path structure.
763 @param TextDeviceNode The input Text device path node.
765 @return A pointer to the newly-created PCIE root device path structure.
768 EFI_DEVICE_PATH_PROTOCOL
*
769 DevPathFromTextPcieRoot (
770 IN CHAR16
*TextDeviceNode
773 return ConvertFromTextAcpi (TextDeviceNode
, 0x0a08);
777 Converts a text device path node to Floppy device path structure.
779 @param TextDeviceNode The input Text device path node.
781 @return A pointer to the newly-created Floppy device path structure.
784 EFI_DEVICE_PATH_PROTOCOL
*
785 DevPathFromTextFloppy (
786 IN CHAR16
*TextDeviceNode
789 return ConvertFromTextAcpi (TextDeviceNode
, 0x0604);
793 Converts a text device path node to Keyboard device path structure.
795 @param TextDeviceNode The input Text device path node.
797 @return A pointer to the newly-created Keyboard device path structure.
800 EFI_DEVICE_PATH_PROTOCOL
*
801 DevPathFromTextKeyboard (
802 IN CHAR16
*TextDeviceNode
805 return ConvertFromTextAcpi (TextDeviceNode
, 0x0301);
809 Converts a text device path node to Serial device path structure.
811 @param TextDeviceNode The input Text device path node.
813 @return A pointer to the newly-created Serial device path structure.
816 EFI_DEVICE_PATH_PROTOCOL
*
817 DevPathFromTextSerial (
818 IN CHAR16
*TextDeviceNode
821 return ConvertFromTextAcpi (TextDeviceNode
, 0x0501);
825 Converts a text device path node to Parallel Port device path structure.
827 @param TextDeviceNode The input Text device path node.
829 @return A pointer to the newly-created Parallel Port device path structure.
832 EFI_DEVICE_PATH_PROTOCOL
*
833 DevPathFromTextParallelPort (
834 IN CHAR16
*TextDeviceNode
837 return ConvertFromTextAcpi (TextDeviceNode
, 0x0401);
841 Converts a text device path node to ACPI extension device path structure.
843 @param TextDeviceNode The input Text device path node.
845 @return A pointer to the newly-created ACPI extension device path structure.
848 EFI_DEVICE_PATH_PROTOCOL
*
849 DevPathFromTextAcpiEx (
850 IN CHAR16
*TextDeviceNode
861 ACPI_EXTENDED_HID_DEVICE_PATH
*AcpiEx
;
863 HIDStr
= GetNextParamStr (&TextDeviceNode
);
864 CIDStr
= GetNextParamStr (&TextDeviceNode
);
865 UIDStr
= GetNextParamStr (&TextDeviceNode
);
866 HIDSTRStr
= GetNextParamStr (&TextDeviceNode
);
867 CIDSTRStr
= GetNextParamStr (&TextDeviceNode
);
868 UIDSTRStr
= GetNextParamStr (&TextDeviceNode
);
870 Length
= (UINT16
) (sizeof (ACPI_EXTENDED_HID_DEVICE_PATH
) + StrLen (HIDSTRStr
) + 1);
871 Length
= (UINT16
) (Length
+ StrLen (UIDSTRStr
) + 1);
872 Length
= (UINT16
) (Length
+ StrLen (CIDSTRStr
) + 1);
873 AcpiEx
= (ACPI_EXTENDED_HID_DEVICE_PATH
*) CreateDeviceNode (
879 AcpiEx
->HID
= EisaIdFromText (HIDStr
);
880 AcpiEx
->CID
= EisaIdFromText (CIDStr
);
881 AcpiEx
->UID
= (UINT32
) Strtoi (UIDStr
);
883 AsciiStr
= (CHAR8
*) ((UINT8
*)AcpiEx
+ sizeof (ACPI_EXTENDED_HID_DEVICE_PATH
));
884 StrToAscii (HIDSTRStr
, &AsciiStr
);
885 StrToAscii (UIDSTRStr
, &AsciiStr
);
886 StrToAscii (CIDSTRStr
, &AsciiStr
);
888 return (EFI_DEVICE_PATH_PROTOCOL
*) AcpiEx
;
892 Converts a text device path node to ACPI extension device path structure.
894 @param TextDeviceNode The input Text device path node.
896 @return A pointer to the newly-created ACPI extension device path structure.
899 EFI_DEVICE_PATH_PROTOCOL
*
900 DevPathFromTextAcpiExp (
901 IN CHAR16
*TextDeviceNode
909 ACPI_EXTENDED_HID_DEVICE_PATH
*AcpiEx
;
911 HIDStr
= GetNextParamStr (&TextDeviceNode
);
912 CIDStr
= GetNextParamStr (&TextDeviceNode
);
913 UIDSTRStr
= GetNextParamStr (&TextDeviceNode
);
914 Length
= (UINT16
) (sizeof (ACPI_EXTENDED_HID_DEVICE_PATH
) + StrLen (UIDSTRStr
) + 3);
915 AcpiEx
= (ACPI_EXTENDED_HID_DEVICE_PATH
*) CreateDeviceNode (
921 AcpiEx
->HID
= EisaIdFromText (HIDStr
);
922 AcpiEx
->CID
= EisaIdFromText (CIDStr
);
925 AsciiStr
= (CHAR8
*) ((UINT8
*)AcpiEx
+ sizeof (ACPI_EXTENDED_HID_DEVICE_PATH
));
927 // HID string is NULL
931 // Convert UID string
934 StrToAscii (UIDSTRStr
, &AsciiStr
);
936 // CID string is NULL
940 return (EFI_DEVICE_PATH_PROTOCOL
*) AcpiEx
;
944 Converts a text device path node to ACPI _ADR device path structure.
946 @param TextDeviceNode The input Text device path node.
948 @return A pointer to the newly-created ACPI _ADR device path structure.
951 EFI_DEVICE_PATH_PROTOCOL
*
952 DevPathFromTextAcpiAdr (
953 IN CHAR16
*TextDeviceNode
956 CHAR16
*DisplayDeviceStr
;
957 ACPI_ADR_DEVICE_PATH
*AcpiAdr
;
961 AcpiAdr
= (ACPI_ADR_DEVICE_PATH
*) CreateDeviceNode (
964 (UINT16
) sizeof (ACPI_ADR_DEVICE_PATH
)
966 ASSERT (AcpiAdr
!= NULL
);
968 for (Index
= 0; ; Index
++) {
969 DisplayDeviceStr
= GetNextParamStr (&TextDeviceNode
);
970 if (IS_NULL (*DisplayDeviceStr
)) {
974 Length
= DevicePathNodeLength (AcpiAdr
);
975 AcpiAdr
= ReallocatePool (
977 Length
+ sizeof (UINT32
),
980 ASSERT (AcpiAdr
!= NULL
);
981 SetDevicePathNodeLength (AcpiAdr
, Length
+ sizeof (UINT32
));
984 (&AcpiAdr
->ADR
)[Index
] = (UINT32
) Strtoi (DisplayDeviceStr
);
987 return (EFI_DEVICE_PATH_PROTOCOL
*) AcpiAdr
;
991 Converts a generic messaging text device path node to messaging device path structure.
993 @param TextDeviceNode The input Text device path node.
995 @return A pointer to messaging device path structure.
998 EFI_DEVICE_PATH_PROTOCOL
*
1000 IN CHAR16
*TextDeviceNode
1003 return DevPathFromTextGenericPath (MESSAGING_DEVICE_PATH
, TextDeviceNode
);
1007 Converts a text device path node to Parallel Port device path structure.
1009 @param TextDeviceNode The input Text device path node.
1011 @return A pointer to the newly-created Parallel Port device path structure.
1014 EFI_DEVICE_PATH_PROTOCOL
*
1015 DevPathFromTextAta (
1016 IN CHAR16
*TextDeviceNode
1019 CHAR16
*PrimarySecondaryStr
;
1020 CHAR16
*SlaveMasterStr
;
1022 ATAPI_DEVICE_PATH
*Atapi
;
1024 Atapi
= (ATAPI_DEVICE_PATH
*) CreateDeviceNode (
1025 MESSAGING_DEVICE_PATH
,
1027 (UINT16
) sizeof (ATAPI_DEVICE_PATH
)
1030 PrimarySecondaryStr
= GetNextParamStr (&TextDeviceNode
);
1031 SlaveMasterStr
= GetNextParamStr (&TextDeviceNode
);
1032 LunStr
= GetNextParamStr (&TextDeviceNode
);
1034 if (StrCmp (PrimarySecondaryStr
, L
"Primary") == 0) {
1035 Atapi
->PrimarySecondary
= 0;
1036 } else if (StrCmp (PrimarySecondaryStr
, L
"Secondary") == 0) {
1037 Atapi
->PrimarySecondary
= 1;
1039 Atapi
->PrimarySecondary
= (UINT8
) Strtoi (PrimarySecondaryStr
);
1041 if (StrCmp (SlaveMasterStr
, L
"Master") == 0) {
1042 Atapi
->SlaveMaster
= 0;
1043 } else if (StrCmp (SlaveMasterStr
, L
"Slave") == 0) {
1044 Atapi
->SlaveMaster
= 1;
1046 Atapi
->SlaveMaster
= (UINT8
) Strtoi (SlaveMasterStr
);
1049 Atapi
->Lun
= (UINT16
) Strtoi (LunStr
);
1051 return (EFI_DEVICE_PATH_PROTOCOL
*) Atapi
;
1055 Converts a text device path node to SCSI device path structure.
1057 @param TextDeviceNode The input Text device path node.
1059 @return A pointer to the newly-created SCSI device path structure.
1062 EFI_DEVICE_PATH_PROTOCOL
*
1063 DevPathFromTextScsi (
1064 IN CHAR16
*TextDeviceNode
1069 SCSI_DEVICE_PATH
*Scsi
;
1071 PunStr
= GetNextParamStr (&TextDeviceNode
);
1072 LunStr
= GetNextParamStr (&TextDeviceNode
);
1073 Scsi
= (SCSI_DEVICE_PATH
*) CreateDeviceNode (
1074 MESSAGING_DEVICE_PATH
,
1076 (UINT16
) sizeof (SCSI_DEVICE_PATH
)
1079 Scsi
->Pun
= (UINT16
) Strtoi (PunStr
);
1080 Scsi
->Lun
= (UINT16
) Strtoi (LunStr
);
1082 return (EFI_DEVICE_PATH_PROTOCOL
*) Scsi
;
1086 Converts a text device path node to Fibre device path structure.
1088 @param TextDeviceNode The input Text device path node.
1090 @return A pointer to the newly-created Fibre device path structure.
1093 EFI_DEVICE_PATH_PROTOCOL
*
1094 DevPathFromTextFibre (
1095 IN CHAR16
*TextDeviceNode
1100 FIBRECHANNEL_DEVICE_PATH
*Fibre
;
1102 WWNStr
= GetNextParamStr (&TextDeviceNode
);
1103 LunStr
= GetNextParamStr (&TextDeviceNode
);
1104 Fibre
= (FIBRECHANNEL_DEVICE_PATH
*) CreateDeviceNode (
1105 MESSAGING_DEVICE_PATH
,
1106 MSG_FIBRECHANNEL_DP
,
1107 (UINT16
) sizeof (FIBRECHANNEL_DEVICE_PATH
)
1110 Fibre
->Reserved
= 0;
1111 Strtoi64 (WWNStr
, &Fibre
->WWN
);
1112 Strtoi64 (LunStr
, &Fibre
->Lun
);
1114 return (EFI_DEVICE_PATH_PROTOCOL
*) Fibre
;
1118 Converts a text device path node to FibreEx device path structure.
1120 @param TextDeviceNode The input Text device path node.
1122 @return A pointer to the newly-created FibreEx device path structure.
1125 EFI_DEVICE_PATH_PROTOCOL
*
1126 DevPathFromTextFibreEx (
1127 IN CHAR16
*TextDeviceNode
1132 FIBRECHANNELEX_DEVICE_PATH
*FibreEx
;
1134 WWNStr
= GetNextParamStr (&TextDeviceNode
);
1135 LunStr
= GetNextParamStr (&TextDeviceNode
);
1136 FibreEx
= (FIBRECHANNELEX_DEVICE_PATH
*) CreateDeviceNode (
1137 MESSAGING_DEVICE_PATH
,
1138 MSG_FIBRECHANNELEX_DP
,
1139 (UINT16
) sizeof (FIBRECHANNELEX_DEVICE_PATH
)
1142 FibreEx
->Reserved
= 0;
1143 Strtoi64 (WWNStr
, (UINT64
*) (&FibreEx
->WWN
));
1144 Strtoi64 (LunStr
, (UINT64
*) (&FibreEx
->Lun
));
1146 *(UINT64
*) (&FibreEx
->WWN
) = SwapBytes64 (*(UINT64
*) (&FibreEx
->WWN
));
1147 *(UINT64
*) (&FibreEx
->Lun
) = SwapBytes64 (*(UINT64
*) (&FibreEx
->Lun
));
1149 return (EFI_DEVICE_PATH_PROTOCOL
*) FibreEx
;
1153 Converts a text device path node to 1394 device path structure.
1155 @param TextDeviceNode The input Text device path node.
1157 @return A pointer to the newly-created 1394 device path structure.
1160 EFI_DEVICE_PATH_PROTOCOL
*
1161 DevPathFromText1394 (
1162 IN CHAR16
*TextDeviceNode
1166 F1394_DEVICE_PATH
*F1394DevPath
;
1168 GuidStr
= GetNextParamStr (&TextDeviceNode
);
1169 F1394DevPath
= (F1394_DEVICE_PATH
*) CreateDeviceNode (
1170 MESSAGING_DEVICE_PATH
,
1172 (UINT16
) sizeof (F1394_DEVICE_PATH
)
1175 F1394DevPath
->Reserved
= 0;
1176 F1394DevPath
->Guid
= StrHexToUint64 (GuidStr
);
1178 return (EFI_DEVICE_PATH_PROTOCOL
*) F1394DevPath
;
1182 Converts a text device path node to USB device path structure.
1184 @param TextDeviceNode The input Text device path node.
1186 @return A pointer to the newly-created USB device path structure.
1189 EFI_DEVICE_PATH_PROTOCOL
*
1190 DevPathFromTextUsb (
1191 IN CHAR16
*TextDeviceNode
1195 CHAR16
*InterfaceStr
;
1196 USB_DEVICE_PATH
*Usb
;
1198 PortStr
= GetNextParamStr (&TextDeviceNode
);
1199 InterfaceStr
= GetNextParamStr (&TextDeviceNode
);
1200 Usb
= (USB_DEVICE_PATH
*) CreateDeviceNode (
1201 MESSAGING_DEVICE_PATH
,
1203 (UINT16
) sizeof (USB_DEVICE_PATH
)
1206 Usb
->ParentPortNumber
= (UINT8
) Strtoi (PortStr
);
1207 Usb
->InterfaceNumber
= (UINT8
) Strtoi (InterfaceStr
);
1209 return (EFI_DEVICE_PATH_PROTOCOL
*) Usb
;
1213 Converts a text device path node to I20 device path structure.
1215 @param TextDeviceNode The input Text device path node.
1217 @return A pointer to the newly-created I20 device path structure.
1220 EFI_DEVICE_PATH_PROTOCOL
*
1221 DevPathFromTextI2O (
1222 IN CHAR16
*TextDeviceNode
1226 I2O_DEVICE_PATH
*I2ODevPath
;
1228 TIDStr
= GetNextParamStr (&TextDeviceNode
);
1229 I2ODevPath
= (I2O_DEVICE_PATH
*) CreateDeviceNode (
1230 MESSAGING_DEVICE_PATH
,
1232 (UINT16
) sizeof (I2O_DEVICE_PATH
)
1235 I2ODevPath
->Tid
= (UINT32
) Strtoi (TIDStr
);
1237 return (EFI_DEVICE_PATH_PROTOCOL
*) I2ODevPath
;
1241 Converts a text device path node to Infini Band device path structure.
1243 @param TextDeviceNode The input Text device path node.
1245 @return A pointer to the newly-created Infini Band device path structure.
1248 EFI_DEVICE_PATH_PROTOCOL
*
1249 DevPathFromTextInfiniband (
1250 IN CHAR16
*TextDeviceNode
1258 INFINIBAND_DEVICE_PATH
*InfiniBand
;
1260 FlagsStr
= GetNextParamStr (&TextDeviceNode
);
1261 GuidStr
= GetNextParamStr (&TextDeviceNode
);
1262 SidStr
= GetNextParamStr (&TextDeviceNode
);
1263 TidStr
= GetNextParamStr (&TextDeviceNode
);
1264 DidStr
= GetNextParamStr (&TextDeviceNode
);
1265 InfiniBand
= (INFINIBAND_DEVICE_PATH
*) CreateDeviceNode (
1266 MESSAGING_DEVICE_PATH
,
1268 (UINT16
) sizeof (INFINIBAND_DEVICE_PATH
)
1271 InfiniBand
->ResourceFlags
= (UINT32
) Strtoi (FlagsStr
);
1272 StrToGuid (GuidStr
, (EFI_GUID
*) InfiniBand
->PortGid
);
1273 Strtoi64 (SidStr
, &InfiniBand
->ServiceId
);
1274 Strtoi64 (TidStr
, &InfiniBand
->TargetPortId
);
1275 Strtoi64 (DidStr
, &InfiniBand
->DeviceId
);
1277 return (EFI_DEVICE_PATH_PROTOCOL
*) InfiniBand
;
1281 Converts a text device path node to Vendor-Defined Messaging device path structure.
1283 @param TextDeviceNode The input Text device path node.
1285 @return A pointer to the newly-created Vendor-Defined Messaging device path structure.
1288 EFI_DEVICE_PATH_PROTOCOL
*
1289 DevPathFromTextVenMsg (
1290 IN CHAR16
*TextDeviceNode
1293 return ConvertFromTextVendor (
1295 MESSAGING_DEVICE_PATH
,
1301 Converts a text device path node to Vendor defined PC-ANSI device path structure.
1303 @param TextDeviceNode The input Text device path node.
1305 @return A pointer to the newly-created Vendor defined PC-ANSI device path structure.
1308 EFI_DEVICE_PATH_PROTOCOL
*
1309 DevPathFromTextVenPcAnsi (
1310 IN CHAR16
*TextDeviceNode
1313 VENDOR_DEVICE_PATH
*Vendor
;
1315 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
1316 MESSAGING_DEVICE_PATH
,
1318 (UINT16
) sizeof (VENDOR_DEVICE_PATH
));
1319 CopyGuid (&Vendor
->Guid
, &gEfiPcAnsiGuid
);
1321 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
1325 Converts a text device path node to Vendor defined VT100 device path structure.
1327 @param TextDeviceNode The input Text device path node.
1329 @return A pointer to the newly-created Vendor defined VT100 device path structure.
1332 EFI_DEVICE_PATH_PROTOCOL
*
1333 DevPathFromTextVenVt100 (
1334 IN CHAR16
*TextDeviceNode
1337 VENDOR_DEVICE_PATH
*Vendor
;
1339 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
1340 MESSAGING_DEVICE_PATH
,
1342 (UINT16
) sizeof (VENDOR_DEVICE_PATH
));
1343 CopyGuid (&Vendor
->Guid
, &gEfiVT100Guid
);
1345 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
1349 Converts a text device path node to Vendor defined VT100 Plus device path structure.
1351 @param TextDeviceNode The input Text device path node.
1353 @return A pointer to the newly-created Vendor defined VT100 Plus device path structure.
1356 EFI_DEVICE_PATH_PROTOCOL
*
1357 DevPathFromTextVenVt100Plus (
1358 IN CHAR16
*TextDeviceNode
1361 VENDOR_DEVICE_PATH
*Vendor
;
1363 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
1364 MESSAGING_DEVICE_PATH
,
1366 (UINT16
) sizeof (VENDOR_DEVICE_PATH
));
1367 CopyGuid (&Vendor
->Guid
, &gEfiVT100PlusGuid
);
1369 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
1373 Converts a text device path node to Vendor defined UTF8 device path structure.
1375 @param TextDeviceNode The input Text device path node.
1377 @return A pointer to the newly-created Vendor defined UTF8 device path structure.
1380 EFI_DEVICE_PATH_PROTOCOL
*
1381 DevPathFromTextVenUtf8 (
1382 IN CHAR16
*TextDeviceNode
1385 VENDOR_DEVICE_PATH
*Vendor
;
1387 Vendor
= (VENDOR_DEVICE_PATH
*) CreateDeviceNode (
1388 MESSAGING_DEVICE_PATH
,
1390 (UINT16
) sizeof (VENDOR_DEVICE_PATH
));
1391 CopyGuid (&Vendor
->Guid
, &gEfiVTUTF8Guid
);
1393 return (EFI_DEVICE_PATH_PROTOCOL
*) Vendor
;
1397 Converts a text device path node to UART Flow Control device path structure.
1399 @param TextDeviceNode The input Text device path node.
1401 @return A pointer to the newly-created UART Flow Control device path structure.
1404 EFI_DEVICE_PATH_PROTOCOL
*
1405 DevPathFromTextUartFlowCtrl (
1406 IN CHAR16
*TextDeviceNode
1410 UART_FLOW_CONTROL_DEVICE_PATH
*UartFlowControl
;
1412 ValueStr
= GetNextParamStr (&TextDeviceNode
);
1413 UartFlowControl
= (UART_FLOW_CONTROL_DEVICE_PATH
*) CreateDeviceNode (
1414 MESSAGING_DEVICE_PATH
,
1416 (UINT16
) sizeof (UART_FLOW_CONTROL_DEVICE_PATH
)
1419 CopyGuid (&UartFlowControl
->Guid
, &gEfiUartDevicePathGuid
);
1420 if (StrCmp (ValueStr
, L
"XonXoff") == 0) {
1421 UartFlowControl
->FlowControlMap
= 2;
1422 } else if (StrCmp (ValueStr
, L
"Hardware") == 0) {
1423 UartFlowControl
->FlowControlMap
= 1;
1425 UartFlowControl
->FlowControlMap
= 0;
1428 return (EFI_DEVICE_PATH_PROTOCOL
*) UartFlowControl
;
1432 Converts a text device path node to Serial Attached SCSI device path structure.
1434 @param TextDeviceNode The input Text device path node.
1436 @return A pointer to the newly-created Serial Attached SCSI device path structure.
1439 EFI_DEVICE_PATH_PROTOCOL
*
1440 DevPathFromTextSAS (
1441 IN CHAR16
*TextDeviceNode
1448 CHAR16
*LocationStr
;
1450 CHAR16
*DriveBayStr
;
1451 CHAR16
*ReservedStr
;
1454 SAS_DEVICE_PATH
*Sas
;
1456 AddressStr
= GetNextParamStr (&TextDeviceNode
);
1457 LunStr
= GetNextParamStr (&TextDeviceNode
);
1458 RTPStr
= GetNextParamStr (&TextDeviceNode
);
1459 SASSATAStr
= GetNextParamStr (&TextDeviceNode
);
1460 LocationStr
= GetNextParamStr (&TextDeviceNode
);
1461 ConnectStr
= GetNextParamStr (&TextDeviceNode
);
1462 DriveBayStr
= GetNextParamStr (&TextDeviceNode
);
1463 ReservedStr
= GetNextParamStr (&TextDeviceNode
);
1464 Sas
= (SAS_DEVICE_PATH
*) CreateDeviceNode (
1465 MESSAGING_DEVICE_PATH
,
1467 (UINT16
) sizeof (SAS_DEVICE_PATH
)
1470 CopyGuid (&Sas
->Guid
, &gEfiSasDevicePathGuid
);
1471 Strtoi64 (AddressStr
, &Sas
->SasAddress
);
1472 Strtoi64 (LunStr
, &Sas
->Lun
);
1473 Sas
->RelativeTargetPort
= (UINT16
) Strtoi (RTPStr
);
1475 if (StrCmp (SASSATAStr
, L
"NoTopology") == 0) {
1478 } else if ((StrCmp (SASSATAStr
, L
"SATA") == 0) || (StrCmp (SASSATAStr
, L
"SAS") == 0)) {
1480 Uint16
= (UINT16
) Strtoi (DriveBayStr
);
1484 Info
= (UINT16
) (0x2 | ((Uint16
- 1) << 8));
1487 if (StrCmp (SASSATAStr
, L
"SATA") == 0) {
1492 // Location is an integer between 0 and 1 or else
1493 // the keyword Internal (0) or External (1).
1495 if (StrCmp (LocationStr
, L
"External") == 0) {
1497 } else if (StrCmp (LocationStr
, L
"Internal") == 0) {
1500 Uint16
= ((UINT16
) Strtoi (LocationStr
) & BIT0
);
1502 Info
|= (Uint16
<< 5);
1505 // Connect is an integer between 0 and 3 or else
1506 // the keyword Direct (0) or Expanded (1).
1508 if (StrCmp (ConnectStr
, L
"Expanded") == 0) {
1510 } else if (StrCmp (ConnectStr
, L
"Direct") == 0) {
1513 Uint16
= ((UINT16
) Strtoi (ConnectStr
) & (BIT0
| BIT1
));
1515 Info
|= (Uint16
<< 6);
1518 Info
= (UINT16
) Strtoi (SASSATAStr
);
1521 Sas
->DeviceTopology
= Info
;
1522 Sas
->Reserved
= (UINT32
) Strtoi (ReservedStr
);
1524 return (EFI_DEVICE_PATH_PROTOCOL
*) Sas
;
1528 Converts a text device path node to Serial Attached SCSI Ex device path structure.
1530 @param TextDeviceNode The input Text device path node.
1532 @return A pointer to the newly-created Serial Attached SCSI Ex device path structure.
1535 EFI_DEVICE_PATH_PROTOCOL
*
1536 DevPathFromTextSasEx (
1537 IN CHAR16
*TextDeviceNode
1544 CHAR16
*LocationStr
;
1546 CHAR16
*DriveBayStr
;
1551 SASEX_DEVICE_PATH
*SasEx
;
1553 AddressStr
= GetNextParamStr (&TextDeviceNode
);
1554 LunStr
= GetNextParamStr (&TextDeviceNode
);
1555 RTPStr
= GetNextParamStr (&TextDeviceNode
);
1556 SASSATAStr
= GetNextParamStr (&TextDeviceNode
);
1557 LocationStr
= GetNextParamStr (&TextDeviceNode
);
1558 ConnectStr
= GetNextParamStr (&TextDeviceNode
);
1559 DriveBayStr
= GetNextParamStr (&TextDeviceNode
);
1560 SasEx
= (SASEX_DEVICE_PATH
*) CreateDeviceNode (
1561 MESSAGING_DEVICE_PATH
,
1563 (UINT16
) sizeof (SASEX_DEVICE_PATH
)
1566 Strtoi64 (AddressStr
, &SasAddress
);
1567 Strtoi64 (LunStr
, &Lun
);
1568 WriteUnaligned64 ((UINT64
*) &SasEx
->SasAddress
, SwapBytes64 (SasAddress
));
1569 WriteUnaligned64 ((UINT64
*) &SasEx
->Lun
, SwapBytes64 (Lun
));
1570 SasEx
->RelativeTargetPort
= (UINT16
) Strtoi (RTPStr
);
1572 if (StrCmp (SASSATAStr
, L
"NoTopology") == 0) {
1575 } else if ((StrCmp (SASSATAStr
, L
"SATA") == 0) || (StrCmp (SASSATAStr
, L
"SAS") == 0)) {
1577 Uint16
= (UINT16
) Strtoi (DriveBayStr
);
1581 Info
= (UINT16
) (0x2 | ((Uint16
- 1) << 8));
1584 if (StrCmp (SASSATAStr
, L
"SATA") == 0) {
1589 // Location is an integer between 0 and 1 or else
1590 // the keyword Internal (0) or External (1).
1592 if (StrCmp (LocationStr
, L
"External") == 0) {
1594 } else if (StrCmp (LocationStr
, L
"Internal") == 0) {
1597 Uint16
= ((UINT16
) Strtoi (LocationStr
) & BIT0
);
1599 Info
|= (Uint16
<< 5);
1602 // Connect is an integer between 0 and 3 or else
1603 // the keyword Direct (0) or Expanded (1).
1605 if (StrCmp (ConnectStr
, L
"Expanded") == 0) {
1607 } else if (StrCmp (ConnectStr
, L
"Direct") == 0) {
1610 Uint16
= ((UINT16
) Strtoi (ConnectStr
) & (BIT0
| BIT1
));
1612 Info
|= (Uint16
<< 6);
1615 Info
= (UINT16
) Strtoi (SASSATAStr
);
1618 SasEx
->DeviceTopology
= Info
;
1620 return (EFI_DEVICE_PATH_PROTOCOL
*) SasEx
;
1624 Converts a text device path node to NVM Express Namespace device path structure.
1626 @param TextDeviceNode The input Text device path node.
1628 @return A pointer to the newly-created NVM Express Namespace device path structure.
1631 EFI_DEVICE_PATH_PROTOCOL
*
1632 DevPathFromTextNVMe (
1633 IN CHAR16
*TextDeviceNode
1636 CHAR16
*NamespaceIdStr
;
1637 CHAR16
*NamespaceUuidStr
;
1638 NVME_NAMESPACE_DEVICE_PATH
*Nvme
;
1642 NamespaceIdStr
= GetNextParamStr (&TextDeviceNode
);
1643 NamespaceUuidStr
= GetNextParamStr (&TextDeviceNode
);
1644 Nvme
= (NVME_NAMESPACE_DEVICE_PATH
*) CreateDeviceNode (
1645 MESSAGING_DEVICE_PATH
,
1646 MSG_NVME_NAMESPACE_DP
,
1647 (UINT16
) sizeof (NVME_NAMESPACE_DEVICE_PATH
)
1650 Nvme
->NamespaceId
= (UINT32
) Strtoi (NamespaceIdStr
);
1651 Uuid
= (UINT8
*) &Nvme
->NamespaceUuid
;
1653 Index
= sizeof (Nvme
->NamespaceUuid
) / sizeof (UINT8
);
1654 while (Index
-- != 0) {
1655 Uuid
[Index
] = (UINT8
) StrHexToUintn (SplitStr (&NamespaceUuidStr
, L
'-'));
1658 return (EFI_DEVICE_PATH_PROTOCOL
*) Nvme
;
1662 Converts a text device path node to UFS device path structure.
1664 @param TextDeviceNode The input Text device path node.
1666 @return A pointer to the newly-created UFS device path structure.
1669 EFI_DEVICE_PATH_PROTOCOL
*
1670 DevPathFromTextUfs (
1671 IN CHAR16
*TextDeviceNode
1676 UFS_DEVICE_PATH
*Ufs
;
1678 PunStr
= GetNextParamStr (&TextDeviceNode
);
1679 LunStr
= GetNextParamStr (&TextDeviceNode
);
1680 Ufs
= (UFS_DEVICE_PATH
*) CreateDeviceNode (
1681 MESSAGING_DEVICE_PATH
,
1683 (UINT16
) sizeof (UFS_DEVICE_PATH
)
1686 Ufs
->Pun
= (UINT8
) Strtoi (PunStr
);
1687 Ufs
->Lun
= (UINT8
) Strtoi (LunStr
);
1689 return (EFI_DEVICE_PATH_PROTOCOL
*) Ufs
;
1693 Converts a text device path node to SD (Secure Digital) device path structure.
1695 @param TextDeviceNode The input Text device path node.
1697 @return A pointer to the newly-created SD device path structure.
1700 EFI_DEVICE_PATH_PROTOCOL
*
1702 IN CHAR16
*TextDeviceNode
1705 CHAR16
*SlotNumberStr
;
1708 SlotNumberStr
= GetNextParamStr (&TextDeviceNode
);
1709 Sd
= (SD_DEVICE_PATH
*) CreateDeviceNode (
1710 MESSAGING_DEVICE_PATH
,
1712 (UINT16
) sizeof (SD_DEVICE_PATH
)
1715 Sd
->SlotNumber
= (UINT8
) Strtoi (SlotNumberStr
);
1717 return (EFI_DEVICE_PATH_PROTOCOL
*) Sd
;
1721 Converts a text device path node to EMMC (Embedded MMC) device path structure.
1723 @param TextDeviceNode The input Text device path node.
1725 @return A pointer to the newly-created EMMC device path structure.
1728 EFI_DEVICE_PATH_PROTOCOL
*
1729 DevPathFromTextEmmc (
1730 IN CHAR16
*TextDeviceNode
1733 CHAR16
*SlotNumberStr
;
1734 EMMC_DEVICE_PATH
*Emmc
;
1736 SlotNumberStr
= GetNextParamStr (&TextDeviceNode
);
1737 Emmc
= (EMMC_DEVICE_PATH
*) CreateDeviceNode (
1738 MESSAGING_DEVICE_PATH
,
1740 (UINT16
) sizeof (EMMC_DEVICE_PATH
)
1743 Emmc
->SlotNumber
= (UINT8
) Strtoi (SlotNumberStr
);
1745 return (EFI_DEVICE_PATH_PROTOCOL
*) Emmc
;
1749 Converts a text device path node to Debug Port device path structure.
1751 @param TextDeviceNode The input Text device path node.
1753 @return A pointer to the newly-created Debug Port device path structure.
1756 EFI_DEVICE_PATH_PROTOCOL
*
1757 DevPathFromTextDebugPort (
1758 IN CHAR16
*TextDeviceNode
1761 VENDOR_DEFINED_MESSAGING_DEVICE_PATH
*Vend
;
1763 Vend
= (VENDOR_DEFINED_MESSAGING_DEVICE_PATH
*) CreateDeviceNode (
1764 MESSAGING_DEVICE_PATH
,
1766 (UINT16
) sizeof (VENDOR_DEFINED_MESSAGING_DEVICE_PATH
)
1769 CopyGuid (&Vend
->Guid
, &gEfiDebugPortProtocolGuid
);
1771 return (EFI_DEVICE_PATH_PROTOCOL
*) Vend
;
1775 Converts a text device path node to MAC device path structure.
1777 @param TextDeviceNode The input Text device path node.
1779 @return A pointer to the newly-created MAC device path structure.
1782 EFI_DEVICE_PATH_PROTOCOL
*
1783 DevPathFromTextMAC (
1784 IN CHAR16
*TextDeviceNode
1790 MAC_ADDR_DEVICE_PATH
*MACDevPath
;
1792 AddressStr
= GetNextParamStr (&TextDeviceNode
);
1793 IfTypeStr
= GetNextParamStr (&TextDeviceNode
);
1794 MACDevPath
= (MAC_ADDR_DEVICE_PATH
*) CreateDeviceNode (
1795 MESSAGING_DEVICE_PATH
,
1797 (UINT16
) sizeof (MAC_ADDR_DEVICE_PATH
)
1800 MACDevPath
->IfType
= (UINT8
) Strtoi (IfTypeStr
);
1802 Length
= sizeof (EFI_MAC_ADDRESS
);
1803 StrHexToBytes (AddressStr
, Length
* 2, MACDevPath
->MacAddress
.Addr
, Length
);
1805 return (EFI_DEVICE_PATH_PROTOCOL
*) MACDevPath
;
1810 Converts a text format to the network protocol ID.
1812 @param Text String of protocol field.
1814 @return Network protocol ID .
1818 NetworkProtocolFromText (
1822 if (StrCmp (Text
, L
"UDP") == 0) {
1823 return RFC_1700_UDP_PROTOCOL
;
1826 if (StrCmp (Text
, L
"TCP") == 0) {
1827 return RFC_1700_TCP_PROTOCOL
;
1830 return Strtoi (Text
);
1835 Converts a text device path node to IPV4 device path structure.
1837 @param TextDeviceNode The input Text device path node.
1839 @return A pointer to the newly-created IPV4 device path structure.
1842 EFI_DEVICE_PATH_PROTOCOL
*
1843 DevPathFromTextIPv4 (
1844 IN CHAR16
*TextDeviceNode
1847 CHAR16
*RemoteIPStr
;
1848 CHAR16
*ProtocolStr
;
1851 CHAR16
*GatewayIPStr
;
1852 CHAR16
*SubnetMaskStr
;
1853 IPv4_DEVICE_PATH
*IPv4
;
1855 RemoteIPStr
= GetNextParamStr (&TextDeviceNode
);
1856 ProtocolStr
= GetNextParamStr (&TextDeviceNode
);
1857 TypeStr
= GetNextParamStr (&TextDeviceNode
);
1858 LocalIPStr
= GetNextParamStr (&TextDeviceNode
);
1859 GatewayIPStr
= GetNextParamStr (&TextDeviceNode
);
1860 SubnetMaskStr
= GetNextParamStr (&TextDeviceNode
);
1861 IPv4
= (IPv4_DEVICE_PATH
*) CreateDeviceNode (
1862 MESSAGING_DEVICE_PATH
,
1864 (UINT16
) sizeof (IPv4_DEVICE_PATH
)
1867 StrToIpv4Address (RemoteIPStr
, NULL
, &IPv4
->RemoteIpAddress
, NULL
);
1868 IPv4
->Protocol
= (UINT16
) NetworkProtocolFromText (ProtocolStr
);
1869 if (StrCmp (TypeStr
, L
"Static") == 0) {
1870 IPv4
->StaticIpAddress
= TRUE
;
1872 IPv4
->StaticIpAddress
= FALSE
;
1875 StrToIpv4Address (LocalIPStr
, NULL
, &IPv4
->LocalIpAddress
, NULL
);
1876 if (!IS_NULL (*GatewayIPStr
) && !IS_NULL (*SubnetMaskStr
)) {
1877 StrToIpv4Address (GatewayIPStr
, NULL
, &IPv4
->GatewayIpAddress
, NULL
);
1878 StrToIpv4Address (SubnetMaskStr
, NULL
, &IPv4
->SubnetMask
, NULL
);
1880 ZeroMem (&IPv4
->GatewayIpAddress
, sizeof (IPv4
->GatewayIpAddress
));
1881 ZeroMem (&IPv4
->SubnetMask
, sizeof (IPv4
->SubnetMask
));
1884 IPv4
->LocalPort
= 0;
1885 IPv4
->RemotePort
= 0;
1887 return (EFI_DEVICE_PATH_PROTOCOL
*) IPv4
;
1891 Converts a text device path node to IPV6 device path structure.
1893 @param TextDeviceNode The input Text device path node.
1895 @return A pointer to the newly-created IPV6 device path structure.
1898 EFI_DEVICE_PATH_PROTOCOL
*
1899 DevPathFromTextIPv6 (
1900 IN CHAR16
*TextDeviceNode
1903 CHAR16
*RemoteIPStr
;
1904 CHAR16
*ProtocolStr
;
1907 CHAR16
*GatewayIPStr
;
1908 CHAR16
*PrefixLengthStr
;
1909 IPv6_DEVICE_PATH
*IPv6
;
1911 RemoteIPStr
= GetNextParamStr (&TextDeviceNode
);
1912 ProtocolStr
= GetNextParamStr (&TextDeviceNode
);
1913 TypeStr
= GetNextParamStr (&TextDeviceNode
);
1914 LocalIPStr
= GetNextParamStr (&TextDeviceNode
);
1915 PrefixLengthStr
= GetNextParamStr (&TextDeviceNode
);
1916 GatewayIPStr
= GetNextParamStr (&TextDeviceNode
);
1917 IPv6
= (IPv6_DEVICE_PATH
*) CreateDeviceNode (
1918 MESSAGING_DEVICE_PATH
,
1920 (UINT16
) sizeof (IPv6_DEVICE_PATH
)
1923 StrToIpv6Address (RemoteIPStr
, NULL
, &IPv6
->RemoteIpAddress
, NULL
);
1924 IPv6
->Protocol
= (UINT16
) NetworkProtocolFromText (ProtocolStr
);
1925 if (StrCmp (TypeStr
, L
"Static") == 0) {
1926 IPv6
->IpAddressOrigin
= 0;
1927 } else if (StrCmp (TypeStr
, L
"StatelessAutoConfigure") == 0) {
1928 IPv6
->IpAddressOrigin
= 1;
1930 IPv6
->IpAddressOrigin
= 2;
1933 StrToIpv6Address (LocalIPStr
, NULL
, &IPv6
->LocalIpAddress
, NULL
);
1934 if (!IS_NULL (*GatewayIPStr
) && !IS_NULL (*PrefixLengthStr
)) {
1935 StrToIpv6Address (GatewayIPStr
, NULL
, &IPv6
->GatewayIpAddress
, NULL
);
1936 IPv6
->PrefixLength
= (UINT8
) Strtoi (PrefixLengthStr
);
1938 ZeroMem (&IPv6
->GatewayIpAddress
, sizeof (IPv6
->GatewayIpAddress
));
1939 IPv6
->PrefixLength
= 0;
1942 IPv6
->LocalPort
= 0;
1943 IPv6
->RemotePort
= 0;
1945 return (EFI_DEVICE_PATH_PROTOCOL
*) IPv6
;
1949 Converts a text device path node to UART device path structure.
1951 @param TextDeviceNode The input Text device path node.
1953 @return A pointer to the newly-created UART device path structure.
1956 EFI_DEVICE_PATH_PROTOCOL
*
1957 DevPathFromTextUart (
1958 IN CHAR16
*TextDeviceNode
1962 CHAR16
*DataBitsStr
;
1964 CHAR16
*StopBitsStr
;
1965 UART_DEVICE_PATH
*Uart
;
1967 BaudStr
= GetNextParamStr (&TextDeviceNode
);
1968 DataBitsStr
= GetNextParamStr (&TextDeviceNode
);
1969 ParityStr
= GetNextParamStr (&TextDeviceNode
);
1970 StopBitsStr
= GetNextParamStr (&TextDeviceNode
);
1971 Uart
= (UART_DEVICE_PATH
*) CreateDeviceNode (
1972 MESSAGING_DEVICE_PATH
,
1974 (UINT16
) sizeof (UART_DEVICE_PATH
)
1977 if (StrCmp (BaudStr
, L
"DEFAULT") == 0) {
1978 Uart
->BaudRate
= 115200;
1980 Strtoi64 (BaudStr
, &Uart
->BaudRate
);
1982 Uart
->DataBits
= (UINT8
) ((StrCmp (DataBitsStr
, L
"DEFAULT") == 0) ? 8 : Strtoi (DataBitsStr
));
1983 switch (*ParityStr
) {
2009 Uart
->Parity
= (UINT8
) Strtoi (ParityStr
);
2013 if (StrCmp (StopBitsStr
, L
"D") == 0) {
2014 Uart
->StopBits
= (UINT8
) 0;
2015 } else if (StrCmp (StopBitsStr
, L
"1") == 0) {
2016 Uart
->StopBits
= (UINT8
) 1;
2017 } else if (StrCmp (StopBitsStr
, L
"1.5") == 0) {
2018 Uart
->StopBits
= (UINT8
) 2;
2019 } else if (StrCmp (StopBitsStr
, L
"2") == 0) {
2020 Uart
->StopBits
= (UINT8
) 3;
2022 Uart
->StopBits
= (UINT8
) Strtoi (StopBitsStr
);
2025 return (EFI_DEVICE_PATH_PROTOCOL
*) Uart
;
2029 Converts a text device path node to USB class device path structure.
2031 @param TextDeviceNode The input Text device path node.
2032 @param UsbClassText A pointer to USB_CLASS_TEXT structure to be integrated to USB Class Text.
2034 @return A pointer to the newly-created USB class device path structure.
2037 EFI_DEVICE_PATH_PROTOCOL
*
2038 ConvertFromTextUsbClass (
2039 IN CHAR16
*TextDeviceNode
,
2040 IN USB_CLASS_TEXT
*UsbClassText
2046 CHAR16
*SubClassStr
;
2047 CHAR16
*ProtocolStr
;
2048 USB_CLASS_DEVICE_PATH
*UsbClass
;
2050 UsbClass
= (USB_CLASS_DEVICE_PATH
*) CreateDeviceNode (
2051 MESSAGING_DEVICE_PATH
,
2053 (UINT16
) sizeof (USB_CLASS_DEVICE_PATH
)
2056 VIDStr
= GetNextParamStr (&TextDeviceNode
);
2057 PIDStr
= GetNextParamStr (&TextDeviceNode
);
2058 if (UsbClassText
->ClassExist
) {
2059 ClassStr
= GetNextParamStr (&TextDeviceNode
);
2060 UsbClass
->DeviceClass
= (UINT8
) Strtoi (ClassStr
);
2062 UsbClass
->DeviceClass
= UsbClassText
->Class
;
2064 if (UsbClassText
->SubClassExist
) {
2065 SubClassStr
= GetNextParamStr (&TextDeviceNode
);
2066 UsbClass
->DeviceSubClass
= (UINT8
) Strtoi (SubClassStr
);
2068 UsbClass
->DeviceSubClass
= UsbClassText
->SubClass
;
2071 ProtocolStr
= GetNextParamStr (&TextDeviceNode
);
2073 UsbClass
->VendorId
= (UINT16
) Strtoi (VIDStr
);
2074 UsbClass
->ProductId
= (UINT16
) Strtoi (PIDStr
);
2075 UsbClass
->DeviceProtocol
= (UINT8
) Strtoi (ProtocolStr
);
2077 return (EFI_DEVICE_PATH_PROTOCOL
*) UsbClass
;
2082 Converts a text device path node to USB class device path structure.
2084 @param TextDeviceNode The input Text device path node.
2086 @return A pointer to the newly-created USB class device path structure.
2089 EFI_DEVICE_PATH_PROTOCOL
*
2090 DevPathFromTextUsbClass (
2091 IN CHAR16
*TextDeviceNode
2094 USB_CLASS_TEXT UsbClassText
;
2096 UsbClassText
.ClassExist
= TRUE
;
2097 UsbClassText
.SubClassExist
= TRUE
;
2099 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
2103 Converts a text device path node to USB audio device path structure.
2105 @param TextDeviceNode The input Text device path node.
2107 @return A pointer to the newly-created USB audio device path structure.
2110 EFI_DEVICE_PATH_PROTOCOL
*
2111 DevPathFromTextUsbAudio (
2112 IN CHAR16
*TextDeviceNode
2115 USB_CLASS_TEXT UsbClassText
;
2117 UsbClassText
.ClassExist
= FALSE
;
2118 UsbClassText
.Class
= USB_CLASS_AUDIO
;
2119 UsbClassText
.SubClassExist
= TRUE
;
2121 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
2125 Converts a text device path node to USB CDC Control device path structure.
2127 @param TextDeviceNode The input Text device path node.
2129 @return A pointer to the newly-created USB CDC Control device path structure.
2132 EFI_DEVICE_PATH_PROTOCOL
*
2133 DevPathFromTextUsbCDCControl (
2134 IN CHAR16
*TextDeviceNode
2137 USB_CLASS_TEXT UsbClassText
;
2139 UsbClassText
.ClassExist
= FALSE
;
2140 UsbClassText
.Class
= USB_CLASS_CDCCONTROL
;
2141 UsbClassText
.SubClassExist
= TRUE
;
2143 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
2147 Converts a text device path node to USB HID device path structure.
2149 @param TextDeviceNode The input Text device path node.
2151 @return A pointer to the newly-created USB HID device path structure.
2154 EFI_DEVICE_PATH_PROTOCOL
*
2155 DevPathFromTextUsbHID (
2156 IN CHAR16
*TextDeviceNode
2159 USB_CLASS_TEXT UsbClassText
;
2161 UsbClassText
.ClassExist
= FALSE
;
2162 UsbClassText
.Class
= USB_CLASS_HID
;
2163 UsbClassText
.SubClassExist
= TRUE
;
2165 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
2169 Converts a text device path node to USB Image device path structure.
2171 @param TextDeviceNode The input Text device path node.
2173 @return A pointer to the newly-created USB Image device path structure.
2176 EFI_DEVICE_PATH_PROTOCOL
*
2177 DevPathFromTextUsbImage (
2178 IN CHAR16
*TextDeviceNode
2181 USB_CLASS_TEXT UsbClassText
;
2183 UsbClassText
.ClassExist
= FALSE
;
2184 UsbClassText
.Class
= USB_CLASS_IMAGE
;
2185 UsbClassText
.SubClassExist
= TRUE
;
2187 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
2191 Converts a text device path node to USB Print device path structure.
2193 @param TextDeviceNode The input Text device path node.
2195 @return A pointer to the newly-created USB Print device path structure.
2198 EFI_DEVICE_PATH_PROTOCOL
*
2199 DevPathFromTextUsbPrinter (
2200 IN CHAR16
*TextDeviceNode
2203 USB_CLASS_TEXT UsbClassText
;
2205 UsbClassText
.ClassExist
= FALSE
;
2206 UsbClassText
.Class
= USB_CLASS_PRINTER
;
2207 UsbClassText
.SubClassExist
= TRUE
;
2209 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
2213 Converts a text device path node to USB mass storage device path structure.
2215 @param TextDeviceNode The input Text device path node.
2217 @return A pointer to the newly-created USB mass storage device path structure.
2220 EFI_DEVICE_PATH_PROTOCOL
*
2221 DevPathFromTextUsbMassStorage (
2222 IN CHAR16
*TextDeviceNode
2225 USB_CLASS_TEXT UsbClassText
;
2227 UsbClassText
.ClassExist
= FALSE
;
2228 UsbClassText
.Class
= USB_CLASS_MASS_STORAGE
;
2229 UsbClassText
.SubClassExist
= TRUE
;
2231 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
2235 Converts a text device path node to USB HUB device path structure.
2237 @param TextDeviceNode The input Text device path node.
2239 @return A pointer to the newly-created USB HUB device path structure.
2242 EFI_DEVICE_PATH_PROTOCOL
*
2243 DevPathFromTextUsbHub (
2244 IN CHAR16
*TextDeviceNode
2247 USB_CLASS_TEXT UsbClassText
;
2249 UsbClassText
.ClassExist
= FALSE
;
2250 UsbClassText
.Class
= USB_CLASS_HUB
;
2251 UsbClassText
.SubClassExist
= TRUE
;
2253 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
2257 Converts a text device path node to USB CDC data device path structure.
2259 @param TextDeviceNode The input Text device path node.
2261 @return A pointer to the newly-created USB CDC data device path structure.
2264 EFI_DEVICE_PATH_PROTOCOL
*
2265 DevPathFromTextUsbCDCData (
2266 IN CHAR16
*TextDeviceNode
2269 USB_CLASS_TEXT UsbClassText
;
2271 UsbClassText
.ClassExist
= FALSE
;
2272 UsbClassText
.Class
= USB_CLASS_CDCDATA
;
2273 UsbClassText
.SubClassExist
= TRUE
;
2275 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
2279 Converts a text device path node to USB smart card device path structure.
2281 @param TextDeviceNode The input Text device path node.
2283 @return A pointer to the newly-created USB smart card device path structure.
2286 EFI_DEVICE_PATH_PROTOCOL
*
2287 DevPathFromTextUsbSmartCard (
2288 IN CHAR16
*TextDeviceNode
2291 USB_CLASS_TEXT UsbClassText
;
2293 UsbClassText
.ClassExist
= FALSE
;
2294 UsbClassText
.Class
= USB_CLASS_SMART_CARD
;
2295 UsbClassText
.SubClassExist
= TRUE
;
2297 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
2301 Converts a text device path node to USB video device path structure.
2303 @param TextDeviceNode The input Text device path node.
2305 @return A pointer to the newly-created USB video device path structure.
2308 EFI_DEVICE_PATH_PROTOCOL
*
2309 DevPathFromTextUsbVideo (
2310 IN CHAR16
*TextDeviceNode
2313 USB_CLASS_TEXT UsbClassText
;
2315 UsbClassText
.ClassExist
= FALSE
;
2316 UsbClassText
.Class
= USB_CLASS_VIDEO
;
2317 UsbClassText
.SubClassExist
= TRUE
;
2319 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
2323 Converts a text device path node to USB diagnostic device path structure.
2325 @param TextDeviceNode The input Text device path node.
2327 @return A pointer to the newly-created USB diagnostic device path structure.
2330 EFI_DEVICE_PATH_PROTOCOL
*
2331 DevPathFromTextUsbDiagnostic (
2332 IN CHAR16
*TextDeviceNode
2335 USB_CLASS_TEXT UsbClassText
;
2337 UsbClassText
.ClassExist
= FALSE
;
2338 UsbClassText
.Class
= USB_CLASS_DIAGNOSTIC
;
2339 UsbClassText
.SubClassExist
= TRUE
;
2341 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
2345 Converts a text device path node to USB wireless device path structure.
2347 @param TextDeviceNode The input Text device path node.
2349 @return A pointer to the newly-created USB wireless device path structure.
2352 EFI_DEVICE_PATH_PROTOCOL
*
2353 DevPathFromTextUsbWireless (
2354 IN CHAR16
*TextDeviceNode
2357 USB_CLASS_TEXT UsbClassText
;
2359 UsbClassText
.ClassExist
= FALSE
;
2360 UsbClassText
.Class
= USB_CLASS_WIRELESS
;
2361 UsbClassText
.SubClassExist
= TRUE
;
2363 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
2367 Converts a text device path node to USB device firmware update device path structure.
2369 @param TextDeviceNode The input Text device path node.
2371 @return A pointer to the newly-created USB device firmware update device path structure.
2374 EFI_DEVICE_PATH_PROTOCOL
*
2375 DevPathFromTextUsbDeviceFirmwareUpdate (
2376 IN CHAR16
*TextDeviceNode
2379 USB_CLASS_TEXT UsbClassText
;
2381 UsbClassText
.ClassExist
= FALSE
;
2382 UsbClassText
.Class
= USB_CLASS_RESERVE
;
2383 UsbClassText
.SubClassExist
= FALSE
;
2384 UsbClassText
.SubClass
= USB_SUBCLASS_FW_UPDATE
;
2386 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
2390 Converts a text device path node to USB IRDA bridge device path structure.
2392 @param TextDeviceNode The input Text device path node.
2394 @return A pointer to the newly-created USB IRDA bridge device path structure.
2397 EFI_DEVICE_PATH_PROTOCOL
*
2398 DevPathFromTextUsbIrdaBridge (
2399 IN CHAR16
*TextDeviceNode
2402 USB_CLASS_TEXT UsbClassText
;
2404 UsbClassText
.ClassExist
= FALSE
;
2405 UsbClassText
.Class
= USB_CLASS_RESERVE
;
2406 UsbClassText
.SubClassExist
= FALSE
;
2407 UsbClassText
.SubClass
= USB_SUBCLASS_IRDA_BRIDGE
;
2409 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
2413 Converts a text device path node to USB text and measurement device path structure.
2415 @param TextDeviceNode The input Text device path node.
2417 @return A pointer to the newly-created USB text and measurement device path structure.
2420 EFI_DEVICE_PATH_PROTOCOL
*
2421 DevPathFromTextUsbTestAndMeasurement (
2422 IN CHAR16
*TextDeviceNode
2425 USB_CLASS_TEXT UsbClassText
;
2427 UsbClassText
.ClassExist
= FALSE
;
2428 UsbClassText
.Class
= USB_CLASS_RESERVE
;
2429 UsbClassText
.SubClassExist
= FALSE
;
2430 UsbClassText
.SubClass
= USB_SUBCLASS_TEST
;
2432 return ConvertFromTextUsbClass (TextDeviceNode
, &UsbClassText
);
2436 Converts a text device path node to USB WWID device path structure.
2438 @param TextDeviceNode The input Text device path node.
2440 @return A pointer to the newly-created USB WWID device path structure.
2443 EFI_DEVICE_PATH_PROTOCOL
*
2444 DevPathFromTextUsbWwid (
2445 IN CHAR16
*TextDeviceNode
2450 CHAR16
*InterfaceNumStr
;
2451 CHAR16
*SerialNumberStr
;
2452 USB_WWID_DEVICE_PATH
*UsbWwid
;
2453 UINTN SerialNumberStrLen
;
2455 VIDStr
= GetNextParamStr (&TextDeviceNode
);
2456 PIDStr
= GetNextParamStr (&TextDeviceNode
);
2457 InterfaceNumStr
= GetNextParamStr (&TextDeviceNode
);
2458 SerialNumberStr
= GetNextParamStr (&TextDeviceNode
);
2459 SerialNumberStrLen
= StrLen (SerialNumberStr
);
2460 if (SerialNumberStrLen
>= 2 &&
2461 SerialNumberStr
[0] == L
'\"' &&
2462 SerialNumberStr
[SerialNumberStrLen
- 1] == L
'\"'
2464 SerialNumberStr
[SerialNumberStrLen
- 1] = L
'\0';
2466 SerialNumberStrLen
-= 2;
2468 UsbWwid
= (USB_WWID_DEVICE_PATH
*) CreateDeviceNode (
2469 MESSAGING_DEVICE_PATH
,
2471 (UINT16
) (sizeof (USB_WWID_DEVICE_PATH
) + SerialNumberStrLen
* sizeof (CHAR16
))
2473 UsbWwid
->VendorId
= (UINT16
) Strtoi (VIDStr
);
2474 UsbWwid
->ProductId
= (UINT16
) Strtoi (PIDStr
);
2475 UsbWwid
->InterfaceNumber
= (UINT16
) Strtoi (InterfaceNumStr
);
2478 // There is no memory allocated in UsbWwid for the '\0' in SerialNumberStr.
2479 // Therefore, the '\0' will not be copied.
2482 (UINT8
*) UsbWwid
+ sizeof (USB_WWID_DEVICE_PATH
),
2484 SerialNumberStrLen
* sizeof (CHAR16
)
2487 return (EFI_DEVICE_PATH_PROTOCOL
*) UsbWwid
;
2491 Converts a text device path node to Logic Unit device path structure.
2493 @param TextDeviceNode The input Text device path node.
2495 @return A pointer to the newly-created Logic Unit device path structure.
2498 EFI_DEVICE_PATH_PROTOCOL
*
2499 DevPathFromTextUnit (
2500 IN CHAR16
*TextDeviceNode
2504 DEVICE_LOGICAL_UNIT_DEVICE_PATH
*LogicalUnit
;
2506 LunStr
= GetNextParamStr (&TextDeviceNode
);
2507 LogicalUnit
= (DEVICE_LOGICAL_UNIT_DEVICE_PATH
*) CreateDeviceNode (
2508 MESSAGING_DEVICE_PATH
,
2509 MSG_DEVICE_LOGICAL_UNIT_DP
,
2510 (UINT16
) sizeof (DEVICE_LOGICAL_UNIT_DEVICE_PATH
)
2513 LogicalUnit
->Lun
= (UINT8
) Strtoi (LunStr
);
2515 return (EFI_DEVICE_PATH_PROTOCOL
*) LogicalUnit
;
2519 Converts a text device path node to iSCSI device path structure.
2521 @param TextDeviceNode The input Text device path node.
2523 @return A pointer to the newly-created iSCSI device path structure.
2526 EFI_DEVICE_PATH_PROTOCOL
*
2527 DevPathFromTextiSCSI (
2528 IN CHAR16
*TextDeviceNode
2533 CHAR16
*PortalGroupStr
;
2535 CHAR16
*HeaderDigestStr
;
2536 CHAR16
*DataDigestStr
;
2537 CHAR16
*AuthenticationStr
;
2538 CHAR16
*ProtocolStr
;
2540 ISCSI_DEVICE_PATH_WITH_NAME
*ISCSIDevPath
;
2542 NameStr
= GetNextParamStr (&TextDeviceNode
);
2543 PortalGroupStr
= GetNextParamStr (&TextDeviceNode
);
2544 LunStr
= GetNextParamStr (&TextDeviceNode
);
2545 HeaderDigestStr
= GetNextParamStr (&TextDeviceNode
);
2546 DataDigestStr
= GetNextParamStr (&TextDeviceNode
);
2547 AuthenticationStr
= GetNextParamStr (&TextDeviceNode
);
2548 ProtocolStr
= GetNextParamStr (&TextDeviceNode
);
2549 ISCSIDevPath
= (ISCSI_DEVICE_PATH_WITH_NAME
*) CreateDeviceNode (
2550 MESSAGING_DEVICE_PATH
,
2552 (UINT16
) (sizeof (ISCSI_DEVICE_PATH_WITH_NAME
) + StrLen (NameStr
))
2555 AsciiStr
= ISCSIDevPath
->TargetName
;
2556 StrToAscii (NameStr
, &AsciiStr
);
2558 ISCSIDevPath
->TargetPortalGroupTag
= (UINT16
) Strtoi (PortalGroupStr
);
2559 Strtoi64 (LunStr
, &ISCSIDevPath
->Lun
);
2562 if (StrCmp (HeaderDigestStr
, L
"CRC32C") == 0) {
2566 if (StrCmp (DataDigestStr
, L
"CRC32C") == 0) {
2570 if (StrCmp (AuthenticationStr
, L
"None") == 0) {
2574 if (StrCmp (AuthenticationStr
, L
"CHAP_UNI") == 0) {
2578 ISCSIDevPath
->LoginOption
= (UINT16
) Options
;
2580 ISCSIDevPath
->NetworkProtocol
= (UINT16
) StrCmp (ProtocolStr
, L
"TCP");
2582 return (EFI_DEVICE_PATH_PROTOCOL
*) ISCSIDevPath
;
2586 Converts a text device path node to VLAN device path structure.
2588 @param TextDeviceNode The input Text device path node.
2590 @return A pointer to the newly-created VLAN device path structure.
2593 EFI_DEVICE_PATH_PROTOCOL
*
2594 DevPathFromTextVlan (
2595 IN CHAR16
*TextDeviceNode
2599 VLAN_DEVICE_PATH
*Vlan
;
2601 VlanStr
= GetNextParamStr (&TextDeviceNode
);
2602 Vlan
= (VLAN_DEVICE_PATH
*) CreateDeviceNode (
2603 MESSAGING_DEVICE_PATH
,
2605 (UINT16
) sizeof (VLAN_DEVICE_PATH
)
2608 Vlan
->VlanId
= (UINT16
) Strtoi (VlanStr
);
2610 return (EFI_DEVICE_PATH_PROTOCOL
*) Vlan
;
2614 Converts a text device path node to Bluetooth device path structure.
2616 @param TextDeviceNode The input Text device path node.
2618 @return A pointer to the newly-created Bluetooth device path structure.
2621 EFI_DEVICE_PATH_PROTOCOL
*
2622 DevPathFromTextBluetooth (
2623 IN CHAR16
*TextDeviceNode
2626 CHAR16
*BluetoothStr
;
2628 CHAR16
*TempNumBuffer
;
2629 UINTN TempBufferSize
;
2631 BLUETOOTH_DEVICE_PATH
*BluetoothDp
;
2633 BluetoothStr
= GetNextParamStr (&TextDeviceNode
);
2634 BluetoothDp
= (BLUETOOTH_DEVICE_PATH
*) CreateDeviceNode (
2635 MESSAGING_DEVICE_PATH
,
2637 (UINT16
) sizeof (BLUETOOTH_DEVICE_PATH
)
2640 Index
= sizeof (BLUETOOTH_ADDRESS
) - 1;
2641 Walker
= BluetoothStr
;
2642 while (!IS_NULL(*Walker
) && Index
>= 0) {
2643 TempBufferSize
= 2 * sizeof(CHAR16
) + StrSize(L
"0x");
2644 TempNumBuffer
= AllocateZeroPool (TempBufferSize
);
2645 if (TempNumBuffer
== NULL
) {
2648 StrCpyS (TempNumBuffer
, TempBufferSize
/ sizeof (CHAR16
), L
"0x");
2649 StrnCatS (TempNumBuffer
, TempBufferSize
/ sizeof (CHAR16
), Walker
, 2);
2650 BluetoothDp
->BD_ADDR
.Address
[Index
] = (UINT8
)Strtoi (TempNumBuffer
);
2651 FreePool (TempNumBuffer
);
2656 return (EFI_DEVICE_PATH_PROTOCOL
*) BluetoothDp
;
2660 Converts a text device path node to Wi-Fi device path structure.
2662 @param TextDeviceNode The input Text device path node.
2664 @return A pointer to the newly-created Wi-Fi device path structure.
2667 EFI_DEVICE_PATH_PROTOCOL
*
2668 DevPathFromTextWiFi (
2669 IN CHAR16
*TextDeviceNode
2675 WIFI_DEVICE_PATH
*WiFiDp
;
2677 SSIdStr
= GetNextParamStr (&TextDeviceNode
);
2678 WiFiDp
= (WIFI_DEVICE_PATH
*) CreateDeviceNode (
2679 MESSAGING_DEVICE_PATH
,
2681 (UINT16
) sizeof (WIFI_DEVICE_PATH
)
2684 if (NULL
!= SSIdStr
) {
2685 DataLen
= StrLen (SSIdStr
);
2686 if (StrLen (SSIdStr
) > 32) {
2687 SSIdStr
[32] = L
'\0';
2691 UnicodeStrToAsciiStrS (SSIdStr
, AsciiStr
, sizeof (AsciiStr
));
2692 CopyMem (WiFiDp
->SSId
, AsciiStr
, DataLen
);
2695 return (EFI_DEVICE_PATH_PROTOCOL
*) WiFiDp
;
2699 Converts a text device path node to URI device path structure.
2701 @param TextDeviceNode The input Text device path node.
2703 @return A pointer to the newly-created URI device path structure.
2706 EFI_DEVICE_PATH_PROTOCOL
*
2707 DevPathFromTextUri (
2708 IN CHAR16
*TextDeviceNode
2713 URI_DEVICE_PATH
*Uri
;
2715 UriStr
= GetNextParamStr (&TextDeviceNode
);
2716 UriLength
= StrnLenS (UriStr
, MAX_UINT16
- sizeof (URI_DEVICE_PATH
));
2717 Uri
= (URI_DEVICE_PATH
*) CreateDeviceNode (
2718 MESSAGING_DEVICE_PATH
,
2720 (UINT16
) (sizeof (URI_DEVICE_PATH
) + UriLength
)
2723 while (UriLength
-- != 0) {
2724 Uri
->Uri
[UriLength
] = (CHAR8
) UriStr
[UriLength
];
2727 return (EFI_DEVICE_PATH_PROTOCOL
*) Uri
;
2731 Converts a media text device path node to media device path structure.
2733 @param TextDeviceNode The input Text device path node.
2735 @return A pointer to media device path structure.
2738 EFI_DEVICE_PATH_PROTOCOL
*
2739 DevPathFromTextMediaPath (
2740 IN CHAR16
*TextDeviceNode
2743 return DevPathFromTextGenericPath (MEDIA_DEVICE_PATH
, TextDeviceNode
);
2747 Converts a text device path node to HD device path structure.
2749 @param TextDeviceNode The input Text device path node.
2751 @return A pointer to the newly-created HD device path structure.
2754 EFI_DEVICE_PATH_PROTOCOL
*
2756 IN CHAR16
*TextDeviceNode
2759 CHAR16
*PartitionStr
;
2761 CHAR16
*SignatureStr
;
2765 HARDDRIVE_DEVICE_PATH
*Hd
;
2767 PartitionStr
= GetNextParamStr (&TextDeviceNode
);
2768 TypeStr
= GetNextParamStr (&TextDeviceNode
);
2769 SignatureStr
= GetNextParamStr (&TextDeviceNode
);
2770 StartStr
= GetNextParamStr (&TextDeviceNode
);
2771 SizeStr
= GetNextParamStr (&TextDeviceNode
);
2772 Hd
= (HARDDRIVE_DEVICE_PATH
*) CreateDeviceNode (
2775 (UINT16
) sizeof (HARDDRIVE_DEVICE_PATH
)
2778 Hd
->PartitionNumber
= (UINT32
) Strtoi (PartitionStr
);
2780 ZeroMem (Hd
->Signature
, 16);
2781 Hd
->MBRType
= (UINT8
) 0;
2783 if (StrCmp (TypeStr
, L
"MBR") == 0) {
2784 Hd
->SignatureType
= SIGNATURE_TYPE_MBR
;
2787 Signature32
= (UINT32
) Strtoi (SignatureStr
);
2788 CopyMem (Hd
->Signature
, &Signature32
, sizeof (UINT32
));
2789 } else if (StrCmp (TypeStr
, L
"GPT") == 0) {
2790 Hd
->SignatureType
= SIGNATURE_TYPE_GUID
;
2793 StrToGuid (SignatureStr
, (EFI_GUID
*) Hd
->Signature
);
2795 Hd
->SignatureType
= (UINT8
) Strtoi (TypeStr
);
2798 Strtoi64 (StartStr
, &Hd
->PartitionStart
);
2799 Strtoi64 (SizeStr
, &Hd
->PartitionSize
);
2801 return (EFI_DEVICE_PATH_PROTOCOL
*) Hd
;
2805 Converts a text device path node to CDROM device path structure.
2807 @param TextDeviceNode The input Text device path node.
2809 @return A pointer to the newly-created CDROM device path structure.
2812 EFI_DEVICE_PATH_PROTOCOL
*
2813 DevPathFromTextCDROM (
2814 IN CHAR16
*TextDeviceNode
2820 CDROM_DEVICE_PATH
*CDROMDevPath
;
2822 EntryStr
= GetNextParamStr (&TextDeviceNode
);
2823 StartStr
= GetNextParamStr (&TextDeviceNode
);
2824 SizeStr
= GetNextParamStr (&TextDeviceNode
);
2825 CDROMDevPath
= (CDROM_DEVICE_PATH
*) CreateDeviceNode (
2828 (UINT16
) sizeof (CDROM_DEVICE_PATH
)
2831 CDROMDevPath
->BootEntry
= (UINT32
) Strtoi (EntryStr
);
2832 Strtoi64 (StartStr
, &CDROMDevPath
->PartitionStart
);
2833 Strtoi64 (SizeStr
, &CDROMDevPath
->PartitionSize
);
2835 return (EFI_DEVICE_PATH_PROTOCOL
*) CDROMDevPath
;
2839 Converts a text device path node to Vendor-defined media device path structure.
2841 @param TextDeviceNode The input Text device path node.
2843 @return A pointer to the newly-created Vendor-defined media device path structure.
2846 EFI_DEVICE_PATH_PROTOCOL
*
2847 DevPathFromTextVenMedia (
2848 IN CHAR16
*TextDeviceNode
2851 return ConvertFromTextVendor (
2859 Converts a text device path node to File device path structure.
2861 @param TextDeviceNode The input Text device path node.
2863 @return A pointer to the newly-created File device path structure.
2866 EFI_DEVICE_PATH_PROTOCOL
*
2867 DevPathFromTextFilePath (
2868 IN CHAR16
*TextDeviceNode
2871 FILEPATH_DEVICE_PATH
*File
;
2873 File
= (FILEPATH_DEVICE_PATH
*) CreateDeviceNode (
2876 (UINT16
) (sizeof (FILEPATH_DEVICE_PATH
) + StrLen (TextDeviceNode
) * 2)
2879 StrCpyS (File
->PathName
, StrLen (TextDeviceNode
) + 1, TextDeviceNode
);
2881 return (EFI_DEVICE_PATH_PROTOCOL
*) File
;
2885 Converts a text device path node to Media protocol device path structure.
2887 @param TextDeviceNode The input Text device path node.
2889 @return A pointer to the newly-created Media protocol device path structure.
2892 EFI_DEVICE_PATH_PROTOCOL
*
2893 DevPathFromTextMedia (
2894 IN CHAR16
*TextDeviceNode
2898 MEDIA_PROTOCOL_DEVICE_PATH
*Media
;
2900 GuidStr
= GetNextParamStr (&TextDeviceNode
);
2901 Media
= (MEDIA_PROTOCOL_DEVICE_PATH
*) CreateDeviceNode (
2904 (UINT16
) sizeof (MEDIA_PROTOCOL_DEVICE_PATH
)
2907 StrToGuid (GuidStr
, &Media
->Protocol
);
2909 return (EFI_DEVICE_PATH_PROTOCOL
*) Media
;
2913 Converts a text device path node to firmware volume device path structure.
2915 @param TextDeviceNode The input Text device path node.
2917 @return A pointer to the newly-created firmware volume device path structure.
2920 EFI_DEVICE_PATH_PROTOCOL
*
2922 IN CHAR16
*TextDeviceNode
2926 MEDIA_FW_VOL_DEVICE_PATH
*Fv
;
2928 GuidStr
= GetNextParamStr (&TextDeviceNode
);
2929 Fv
= (MEDIA_FW_VOL_DEVICE_PATH
*) CreateDeviceNode (
2931 MEDIA_PIWG_FW_VOL_DP
,
2932 (UINT16
) sizeof (MEDIA_FW_VOL_DEVICE_PATH
)
2935 StrToGuid (GuidStr
, &Fv
->FvName
);
2937 return (EFI_DEVICE_PATH_PROTOCOL
*) Fv
;
2941 Converts a text device path node to firmware file device path structure.
2943 @param TextDeviceNode The input Text device path node.
2945 @return A pointer to the newly-created firmware file device path structure.
2948 EFI_DEVICE_PATH_PROTOCOL
*
2949 DevPathFromTextFvFile (
2950 IN CHAR16
*TextDeviceNode
2954 MEDIA_FW_VOL_FILEPATH_DEVICE_PATH
*FvFile
;
2956 GuidStr
= GetNextParamStr (&TextDeviceNode
);
2957 FvFile
= (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH
*) CreateDeviceNode (
2959 MEDIA_PIWG_FW_FILE_DP
,
2960 (UINT16
) sizeof (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH
)
2963 StrToGuid (GuidStr
, &FvFile
->FvFileName
);
2965 return (EFI_DEVICE_PATH_PROTOCOL
*) FvFile
;
2969 Converts a text device path node to text relative offset device path structure.
2971 @param TextDeviceNode The input Text device path node.
2973 @return A pointer to the newly-created Text device path structure.
2976 EFI_DEVICE_PATH_PROTOCOL
*
2977 DevPathFromTextRelativeOffsetRange (
2978 IN CHAR16
*TextDeviceNode
2981 CHAR16
*StartingOffsetStr
;
2982 CHAR16
*EndingOffsetStr
;
2983 MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH
*Offset
;
2985 StartingOffsetStr
= GetNextParamStr (&TextDeviceNode
);
2986 EndingOffsetStr
= GetNextParamStr (&TextDeviceNode
);
2987 Offset
= (MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH
*) CreateDeviceNode (
2989 MEDIA_RELATIVE_OFFSET_RANGE_DP
,
2990 (UINT16
) sizeof (MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH
)
2993 Strtoi64 (StartingOffsetStr
, &Offset
->StartingOffset
);
2994 Strtoi64 (EndingOffsetStr
, &Offset
->EndingOffset
);
2996 return (EFI_DEVICE_PATH_PROTOCOL
*) Offset
;
3000 Converts a text device path node to text ram disk device path structure.
3002 @param TextDeviceNode The input Text device path node.
3004 @return A pointer to the newly-created Text device path structure.
3007 EFI_DEVICE_PATH_PROTOCOL
*
3008 DevPathFromTextRamDisk (
3009 IN CHAR16
*TextDeviceNode
3012 CHAR16
*StartingAddrStr
;
3013 CHAR16
*EndingAddrStr
;
3014 CHAR16
*TypeGuidStr
;
3015 CHAR16
*InstanceStr
;
3016 MEDIA_RAM_DISK_DEVICE_PATH
*RamDisk
;
3017 UINT64 StartingAddr
;
3020 StartingAddrStr
= GetNextParamStr (&TextDeviceNode
);
3021 EndingAddrStr
= GetNextParamStr (&TextDeviceNode
);
3022 InstanceStr
= GetNextParamStr (&TextDeviceNode
);
3023 TypeGuidStr
= GetNextParamStr (&TextDeviceNode
);
3024 RamDisk
= (MEDIA_RAM_DISK_DEVICE_PATH
*) CreateDeviceNode (
3027 (UINT16
) sizeof (MEDIA_RAM_DISK_DEVICE_PATH
)
3030 Strtoi64 (StartingAddrStr
, &StartingAddr
);
3031 WriteUnaligned64 ((UINT64
*) &(RamDisk
->StartingAddr
[0]), StartingAddr
);
3032 Strtoi64 (EndingAddrStr
, &EndingAddr
);
3033 WriteUnaligned64 ((UINT64
*) &(RamDisk
->EndingAddr
[0]), EndingAddr
);
3034 RamDisk
->Instance
= (UINT16
) Strtoi (InstanceStr
);
3035 StrToGuid (TypeGuidStr
, &RamDisk
->TypeGuid
);
3037 return (EFI_DEVICE_PATH_PROTOCOL
*) RamDisk
;
3041 Converts a text device path node to text virtual disk device path structure.
3043 @param TextDeviceNode The input Text device path node.
3045 @return A pointer to the newly-created Text device path structure.
3048 EFI_DEVICE_PATH_PROTOCOL
*
3049 DevPathFromTextVirtualDisk (
3050 IN CHAR16
*TextDeviceNode
3053 CHAR16
*StartingAddrStr
;
3054 CHAR16
*EndingAddrStr
;
3055 CHAR16
*InstanceStr
;
3056 MEDIA_RAM_DISK_DEVICE_PATH
*RamDisk
;
3057 UINT64 StartingAddr
;
3060 StartingAddrStr
= GetNextParamStr (&TextDeviceNode
);
3061 EndingAddrStr
= GetNextParamStr (&TextDeviceNode
);
3062 InstanceStr
= GetNextParamStr (&TextDeviceNode
);
3064 RamDisk
= (MEDIA_RAM_DISK_DEVICE_PATH
*) CreateDeviceNode (
3067 (UINT16
) sizeof (MEDIA_RAM_DISK_DEVICE_PATH
)
3070 Strtoi64 (StartingAddrStr
, &StartingAddr
);
3071 WriteUnaligned64 ((UINT64
*) &(RamDisk
->StartingAddr
[0]), StartingAddr
);
3072 Strtoi64 (EndingAddrStr
, &EndingAddr
);
3073 WriteUnaligned64 ((UINT64
*) &(RamDisk
->EndingAddr
[0]), EndingAddr
);
3074 RamDisk
->Instance
= (UINT16
) Strtoi (InstanceStr
);
3075 CopyGuid (&RamDisk
->TypeGuid
, &gEfiVirtualDiskGuid
);
3077 return (EFI_DEVICE_PATH_PROTOCOL
*) RamDisk
;
3081 Converts a text device path node to text virtual cd device path structure.
3083 @param TextDeviceNode The input Text device path node.
3085 @return A pointer to the newly-created Text device path structure.
3088 EFI_DEVICE_PATH_PROTOCOL
*
3089 DevPathFromTextVirtualCd (
3090 IN CHAR16
*TextDeviceNode
3093 CHAR16
*StartingAddrStr
;
3094 CHAR16
*EndingAddrStr
;
3095 CHAR16
*InstanceStr
;
3096 MEDIA_RAM_DISK_DEVICE_PATH
*RamDisk
;
3097 UINT64 StartingAddr
;
3100 StartingAddrStr
= GetNextParamStr (&TextDeviceNode
);
3101 EndingAddrStr
= GetNextParamStr (&TextDeviceNode
);
3102 InstanceStr
= GetNextParamStr (&TextDeviceNode
);
3104 RamDisk
= (MEDIA_RAM_DISK_DEVICE_PATH
*) CreateDeviceNode (
3107 (UINT16
) sizeof (MEDIA_RAM_DISK_DEVICE_PATH
)
3110 Strtoi64 (StartingAddrStr
, &StartingAddr
);
3111 WriteUnaligned64 ((UINT64
*) &(RamDisk
->StartingAddr
[0]), StartingAddr
);
3112 Strtoi64 (EndingAddrStr
, &EndingAddr
);
3113 WriteUnaligned64 ((UINT64
*) &(RamDisk
->EndingAddr
[0]), EndingAddr
);
3114 RamDisk
->Instance
= (UINT16
) Strtoi (InstanceStr
);
3115 CopyGuid (&RamDisk
->TypeGuid
, &gEfiVirtualCdGuid
);
3117 return (EFI_DEVICE_PATH_PROTOCOL
*) RamDisk
;
3121 Converts a text device path node to text persistent virtual disk device path structure.
3123 @param TextDeviceNode The input Text device path node.
3125 @return A pointer to the newly-created Text device path structure.
3128 EFI_DEVICE_PATH_PROTOCOL
*
3129 DevPathFromTextPersistentVirtualDisk (
3130 IN CHAR16
*TextDeviceNode
3133 CHAR16
*StartingAddrStr
;
3134 CHAR16
*EndingAddrStr
;
3135 CHAR16
*InstanceStr
;
3136 MEDIA_RAM_DISK_DEVICE_PATH
*RamDisk
;
3137 UINT64 StartingAddr
;
3140 StartingAddrStr
= GetNextParamStr (&TextDeviceNode
);
3141 EndingAddrStr
= GetNextParamStr (&TextDeviceNode
);
3142 InstanceStr
= GetNextParamStr (&TextDeviceNode
);
3144 RamDisk
= (MEDIA_RAM_DISK_DEVICE_PATH
*) CreateDeviceNode (
3147 (UINT16
) sizeof (MEDIA_RAM_DISK_DEVICE_PATH
)
3150 Strtoi64 (StartingAddrStr
, &StartingAddr
);
3151 WriteUnaligned64 ((UINT64
*) &(RamDisk
->StartingAddr
[0]), StartingAddr
);
3152 Strtoi64 (EndingAddrStr
, &EndingAddr
);
3153 WriteUnaligned64 ((UINT64
*) &(RamDisk
->EndingAddr
[0]), EndingAddr
);
3154 RamDisk
->Instance
= (UINT16
) Strtoi (InstanceStr
);
3155 CopyGuid (&RamDisk
->TypeGuid
, &gEfiPersistentVirtualDiskGuid
);
3157 return (EFI_DEVICE_PATH_PROTOCOL
*) RamDisk
;
3161 Converts a text device path node to text persistent virtual cd device path structure.
3163 @param TextDeviceNode The input Text device path node.
3165 @return A pointer to the newly-created Text device path structure.
3168 EFI_DEVICE_PATH_PROTOCOL
*
3169 DevPathFromTextPersistentVirtualCd (
3170 IN CHAR16
*TextDeviceNode
3173 CHAR16
*StartingAddrStr
;
3174 CHAR16
*EndingAddrStr
;
3175 CHAR16
*InstanceStr
;
3176 MEDIA_RAM_DISK_DEVICE_PATH
*RamDisk
;
3177 UINT64 StartingAddr
;
3180 StartingAddrStr
= GetNextParamStr (&TextDeviceNode
);
3181 EndingAddrStr
= GetNextParamStr (&TextDeviceNode
);
3182 InstanceStr
= GetNextParamStr (&TextDeviceNode
);
3184 RamDisk
= (MEDIA_RAM_DISK_DEVICE_PATH
*) CreateDeviceNode (
3187 (UINT16
) sizeof (MEDIA_RAM_DISK_DEVICE_PATH
)
3190 Strtoi64 (StartingAddrStr
, &StartingAddr
);
3191 WriteUnaligned64 ((UINT64
*) &(RamDisk
->StartingAddr
[0]), StartingAddr
);
3192 Strtoi64 (EndingAddrStr
, &EndingAddr
);
3193 WriteUnaligned64 ((UINT64
*) &(RamDisk
->EndingAddr
[0]), EndingAddr
);
3194 RamDisk
->Instance
= (UINT16
) Strtoi (InstanceStr
);
3195 CopyGuid (&RamDisk
->TypeGuid
, &gEfiPersistentVirtualCdGuid
);
3197 return (EFI_DEVICE_PATH_PROTOCOL
*) RamDisk
;
3201 Converts a BBS text device path node to BBS device path structure.
3203 @param TextDeviceNode The input Text device path node.
3205 @return A pointer to BBS device path structure.
3208 EFI_DEVICE_PATH_PROTOCOL
*
3209 DevPathFromTextBbsPath (
3210 IN CHAR16
*TextDeviceNode
3213 return DevPathFromTextGenericPath (BBS_DEVICE_PATH
, TextDeviceNode
);
3217 Converts a text device path node to BIOS Boot Specification device path structure.
3219 @param TextDeviceNode The input Text device path node.
3221 @return A pointer to the newly-created BIOS Boot Specification device path structure.
3224 EFI_DEVICE_PATH_PROTOCOL
*
3225 DevPathFromTextBBS (
3226 IN CHAR16
*TextDeviceNode
3233 BBS_BBS_DEVICE_PATH
*Bbs
;
3235 TypeStr
= GetNextParamStr (&TextDeviceNode
);
3236 IdStr
= GetNextParamStr (&TextDeviceNode
);
3237 FlagsStr
= GetNextParamStr (&TextDeviceNode
);
3238 Bbs
= (BBS_BBS_DEVICE_PATH
*) CreateDeviceNode (
3241 (UINT16
) (sizeof (BBS_BBS_DEVICE_PATH
) + StrLen (IdStr
))
3244 if (StrCmp (TypeStr
, L
"Floppy") == 0) {
3245 Bbs
->DeviceType
= BBS_TYPE_FLOPPY
;
3246 } else if (StrCmp (TypeStr
, L
"HD") == 0) {
3247 Bbs
->DeviceType
= BBS_TYPE_HARDDRIVE
;
3248 } else if (StrCmp (TypeStr
, L
"CDROM") == 0) {
3249 Bbs
->DeviceType
= BBS_TYPE_CDROM
;
3250 } else if (StrCmp (TypeStr
, L
"PCMCIA") == 0) {
3251 Bbs
->DeviceType
= BBS_TYPE_PCMCIA
;
3252 } else if (StrCmp (TypeStr
, L
"USB") == 0) {
3253 Bbs
->DeviceType
= BBS_TYPE_USB
;
3254 } else if (StrCmp (TypeStr
, L
"Network") == 0) {
3255 Bbs
->DeviceType
= BBS_TYPE_EMBEDDED_NETWORK
;
3257 Bbs
->DeviceType
= (UINT16
) Strtoi (TypeStr
);
3260 AsciiStr
= Bbs
->String
;
3261 StrToAscii (IdStr
, &AsciiStr
);
3263 Bbs
->StatusFlag
= (UINT16
) Strtoi (FlagsStr
);
3265 return (EFI_DEVICE_PATH_PROTOCOL
*) Bbs
;
3269 Converts a text device path node to SATA device path structure.
3271 @param TextDeviceNode The input Text device path node.
3273 @return A pointer to the newly-created SATA device path structure.
3276 EFI_DEVICE_PATH_PROTOCOL
*
3277 DevPathFromTextSata (
3278 IN CHAR16
*TextDeviceNode
3281 SATA_DEVICE_PATH
*Sata
;
3286 Param1
= GetNextParamStr (&TextDeviceNode
);
3287 Param2
= GetNextParamStr (&TextDeviceNode
);
3288 Param3
= GetNextParamStr (&TextDeviceNode
);
3290 Sata
= (SATA_DEVICE_PATH
*) CreateDeviceNode (
3291 MESSAGING_DEVICE_PATH
,
3293 (UINT16
) sizeof (SATA_DEVICE_PATH
)
3295 Sata
->HBAPortNumber
= (UINT16
) Strtoi (Param1
);
3296 Sata
->PortMultiplierPortNumber
= (UINT16
) Strtoi (Param2
);
3297 Sata
->Lun
= (UINT16
) Strtoi (Param3
);
3299 return (EFI_DEVICE_PATH_PROTOCOL
*) Sata
;
3302 GLOBAL_REMOVE_IF_UNREFERENCED DEVICE_PATH_FROM_TEXT_TABLE mUefiDevicePathLibDevPathFromTextTable
[] = {
3303 {L
"Path", DevPathFromTextPath
},
3305 {L
"HardwarePath", DevPathFromTextHardwarePath
},
3306 {L
"Pci", DevPathFromTextPci
},
3307 {L
"PcCard", DevPathFromTextPcCard
},
3308 {L
"MemoryMapped", DevPathFromTextMemoryMapped
},
3309 {L
"VenHw", DevPathFromTextVenHw
},
3310 {L
"Ctrl", DevPathFromTextCtrl
},
3311 {L
"BMC", DevPathFromTextBmc
},
3313 {L
"AcpiPath", DevPathFromTextAcpiPath
},
3314 {L
"Acpi", DevPathFromTextAcpi
},
3315 {L
"PciRoot", DevPathFromTextPciRoot
},
3316 {L
"PcieRoot", DevPathFromTextPcieRoot
},
3317 {L
"Floppy", DevPathFromTextFloppy
},
3318 {L
"Keyboard", DevPathFromTextKeyboard
},
3319 {L
"Serial", DevPathFromTextSerial
},
3320 {L
"ParallelPort", DevPathFromTextParallelPort
},
3321 {L
"AcpiEx", DevPathFromTextAcpiEx
},
3322 {L
"AcpiExp", DevPathFromTextAcpiExp
},
3323 {L
"AcpiAdr", DevPathFromTextAcpiAdr
},
3325 {L
"Msg", DevPathFromTextMsg
},
3326 {L
"Ata", DevPathFromTextAta
},
3327 {L
"Scsi", DevPathFromTextScsi
},
3328 {L
"Fibre", DevPathFromTextFibre
},
3329 {L
"FibreEx", DevPathFromTextFibreEx
},
3330 {L
"I1394", DevPathFromText1394
},
3331 {L
"USB", DevPathFromTextUsb
},
3332 {L
"I2O", DevPathFromTextI2O
},
3333 {L
"Infiniband", DevPathFromTextInfiniband
},
3334 {L
"VenMsg", DevPathFromTextVenMsg
},
3335 {L
"VenPcAnsi", DevPathFromTextVenPcAnsi
},
3336 {L
"VenVt100", DevPathFromTextVenVt100
},
3337 {L
"VenVt100Plus", DevPathFromTextVenVt100Plus
},
3338 {L
"VenUtf8", DevPathFromTextVenUtf8
},
3339 {L
"UartFlowCtrl", DevPathFromTextUartFlowCtrl
},
3340 {L
"SAS", DevPathFromTextSAS
},
3341 {L
"SasEx", DevPathFromTextSasEx
},
3342 {L
"NVMe", DevPathFromTextNVMe
},
3343 {L
"UFS", DevPathFromTextUfs
},
3344 {L
"SD", DevPathFromTextSd
},
3345 {L
"eMMC", DevPathFromTextEmmc
},
3346 {L
"DebugPort", DevPathFromTextDebugPort
},
3347 {L
"MAC", DevPathFromTextMAC
},
3348 {L
"IPv4", DevPathFromTextIPv4
},
3349 {L
"IPv6", DevPathFromTextIPv6
},
3350 {L
"Uart", DevPathFromTextUart
},
3351 {L
"UsbClass", DevPathFromTextUsbClass
},
3352 {L
"UsbAudio", DevPathFromTextUsbAudio
},
3353 {L
"UsbCDCControl", DevPathFromTextUsbCDCControl
},
3354 {L
"UsbHID", DevPathFromTextUsbHID
},
3355 {L
"UsbImage", DevPathFromTextUsbImage
},
3356 {L
"UsbPrinter", DevPathFromTextUsbPrinter
},
3357 {L
"UsbMassStorage", DevPathFromTextUsbMassStorage
},
3358 {L
"UsbHub", DevPathFromTextUsbHub
},
3359 {L
"UsbCDCData", DevPathFromTextUsbCDCData
},
3360 {L
"UsbSmartCard", DevPathFromTextUsbSmartCard
},
3361 {L
"UsbVideo", DevPathFromTextUsbVideo
},
3362 {L
"UsbDiagnostic", DevPathFromTextUsbDiagnostic
},
3363 {L
"UsbWireless", DevPathFromTextUsbWireless
},
3364 {L
"UsbDeviceFirmwareUpdate", DevPathFromTextUsbDeviceFirmwareUpdate
},
3365 {L
"UsbIrdaBridge", DevPathFromTextUsbIrdaBridge
},
3366 {L
"UsbTestAndMeasurement", DevPathFromTextUsbTestAndMeasurement
},
3367 {L
"UsbWwid", DevPathFromTextUsbWwid
},
3368 {L
"Unit", DevPathFromTextUnit
},
3369 {L
"iSCSI", DevPathFromTextiSCSI
},
3370 {L
"Vlan", DevPathFromTextVlan
},
3371 {L
"Uri", DevPathFromTextUri
},
3372 {L
"Bluetooth", DevPathFromTextBluetooth
},
3373 {L
"Wi-Fi", DevPathFromTextWiFi
},
3374 {L
"MediaPath", DevPathFromTextMediaPath
},
3375 {L
"HD", DevPathFromTextHD
},
3376 {L
"CDROM", DevPathFromTextCDROM
},
3377 {L
"VenMedia", DevPathFromTextVenMedia
},
3378 {L
"Media", DevPathFromTextMedia
},
3379 {L
"Fv", DevPathFromTextFv
},
3380 {L
"FvFile", DevPathFromTextFvFile
},
3381 {L
"Offset", DevPathFromTextRelativeOffsetRange
},
3382 {L
"RamDisk", DevPathFromTextRamDisk
},
3383 {L
"VirtualDisk", DevPathFromTextVirtualDisk
},
3384 {L
"VirtualCD", DevPathFromTextVirtualCd
},
3385 {L
"PersistentVirtualDisk", DevPathFromTextPersistentVirtualDisk
},
3386 {L
"PersistentVirtualCD", DevPathFromTextPersistentVirtualCd
},
3388 {L
"BbsPath", DevPathFromTextBbsPath
},
3389 {L
"BBS", DevPathFromTextBBS
},
3390 {L
"Sata", DevPathFromTextSata
},
3395 Convert text to the binary representation of a device node.
3397 @param TextDeviceNode TextDeviceNode points to the text representation of a device
3398 node. Conversion starts with the first character and continues
3399 until the first non-device node character.
3401 @return A pointer to the EFI device node or NULL if TextDeviceNode is NULL or there was
3402 insufficient memory or text unsupported.
3405 EFI_DEVICE_PATH_PROTOCOL
*
3407 UefiDevicePathLibConvertTextToDeviceNode (
3408 IN CONST CHAR16
*TextDeviceNode
3411 DEVICE_PATH_FROM_TEXT FromText
;
3413 EFI_DEVICE_PATH_PROTOCOL
*DeviceNode
;
3414 CHAR16
*DeviceNodeStr
;
3417 if ((TextDeviceNode
== NULL
) || (IS_NULL (*TextDeviceNode
))) {
3423 DeviceNodeStr
= UefiDevicePathLibStrDuplicate (TextDeviceNode
);
3424 ASSERT (DeviceNodeStr
!= NULL
);
3426 for (Index
= 0; mUefiDevicePathLibDevPathFromTextTable
[Index
].Function
!= NULL
; Index
++) {
3427 ParamStr
= GetParamByNodeName (DeviceNodeStr
, mUefiDevicePathLibDevPathFromTextTable
[Index
].DevicePathNodeText
);
3428 if (ParamStr
!= NULL
) {
3429 FromText
= mUefiDevicePathLibDevPathFromTextTable
[Index
].Function
;
3434 if (FromText
== NULL
) {
3438 FromText
= DevPathFromTextFilePath
;
3439 DeviceNode
= FromText (DeviceNodeStr
);
3441 DeviceNode
= FromText (ParamStr
);
3442 FreePool (ParamStr
);
3445 FreePool (DeviceNodeStr
);
3451 Convert text to the binary representation of a device path.
3454 @param TextDevicePath TextDevicePath points to the text representation of a device
3455 path. Conversion starts with the first character and continues
3456 until the first non-device node character.
3458 @return A pointer to the allocated device path or NULL if TextDeviceNode is NULL or
3459 there was insufficient memory.
3462 EFI_DEVICE_PATH_PROTOCOL
*
3464 UefiDevicePathLibConvertTextToDevicePath (
3465 IN CONST CHAR16
*TextDevicePath
3468 EFI_DEVICE_PATH_PROTOCOL
*DeviceNode
;
3469 EFI_DEVICE_PATH_PROTOCOL
*NewDevicePath
;
3470 CHAR16
*DevicePathStr
;
3472 CHAR16
*DeviceNodeStr
;
3473 BOOLEAN IsInstanceEnd
;
3474 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
3476 if ((TextDevicePath
== NULL
) || (IS_NULL (*TextDevicePath
))) {
3480 DevicePath
= (EFI_DEVICE_PATH_PROTOCOL
*) AllocatePool (END_DEVICE_PATH_LENGTH
);
3481 ASSERT (DevicePath
!= NULL
);
3482 SetDevicePathEndNode (DevicePath
);
3484 DevicePathStr
= UefiDevicePathLibStrDuplicate (TextDevicePath
);
3486 Str
= DevicePathStr
;
3487 while ((DeviceNodeStr
= GetNextDeviceNodeStr (&Str
, &IsInstanceEnd
)) != NULL
) {
3488 DeviceNode
= UefiDevicePathLibConvertTextToDeviceNode (DeviceNodeStr
);
3490 NewDevicePath
= AppendDevicePathNode (DevicePath
, DeviceNode
);
3491 FreePool (DevicePath
);
3492 FreePool (DeviceNode
);
3493 DevicePath
= NewDevicePath
;
3495 if (IsInstanceEnd
) {
3496 DeviceNode
= (EFI_DEVICE_PATH_PROTOCOL
*) AllocatePool (END_DEVICE_PATH_LENGTH
);
3497 ASSERT (DeviceNode
!= NULL
);
3498 SetDevicePathEndNode (DeviceNode
);
3500 NewDevicePath
= AppendDevicePathNode (DevicePath
, DeviceNode
);
3501 FreePool (DevicePath
);
3502 FreePool (DeviceNode
);
3503 DevicePath
= NewDevicePath
;
3507 FreePool (DevicePathStr
);