VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/MdePkg/Library/UefiDevicePathLib/DevicePathFromText.c@ 58464

Last change on this file since 58464 was 58464, checked in by vboxsync, 9 years ago

EFI/Firmware: Export new files and directories.
  • Property svn:eol-style set to native
File size: 91.1 KB
Line 
1/** @file
2 DevicePathFromText protocol as defined in the UEFI 2.0 specification.
3
4Copyright (c) 2013 - 2014, Intel Corporation. All rights reserved.<BR>
5This program and the accompanying materials
6are licensed and made available under the terms and conditions of the BSD License
7which accompanies this distribution. The full text of the license may be found at
8http://opensource.org/licenses/bsd-license.php
9
10THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13**/
14
15#include "UefiDevicePathLib.h"
16
17/**
18
19 Duplicates a string.
20
21 @param Src Source string.
22
23 @return The duplicated string.
24
25**/
26CHAR16 *
27UefiDevicePathLibStrDuplicate (
28 IN CONST CHAR16 *Src
29 )
30{
31 return AllocateCopyPool (StrSize (Src), Src);
32}
33
34/**
35
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".
38
39 @param Str Device Path Text.
40 @param NodeName Name of the node.
41
42 @return Parameter text for the node.
43
44**/
45CHAR16 *
46GetParamByNodeName (
47 IN CHAR16 *Str,
48 IN CHAR16 *NodeName
49 )
50{
51 CHAR16 *ParamStr;
52 CHAR16 *StrPointer;
53 UINTN NodeNameLength;
54 UINTN ParameterLength;
55
56 //
57 // Check whether the node name matchs
58 //
59 NodeNameLength = StrLen (NodeName);
60 if (StrnCmp (Str, NodeName, NodeNameLength) != 0) {
61 return NULL;
62 }
63
64 ParamStr = Str + NodeNameLength;
65 if (!IS_LEFT_PARENTH (*ParamStr)) {
66 return NULL;
67 }
68
69 //
70 // Skip the found '(' and find first occurrence of ')'
71 //
72 ParamStr++;
73 ParameterLength = 0;
74 StrPointer = ParamStr;
75 while (!IS_NULL (*StrPointer)) {
76 if (IS_RIGHT_PARENTH (*StrPointer)) {
77 break;
78 }
79 StrPointer++;
80 ParameterLength++;
81 }
82 if (IS_NULL (*StrPointer)) {
83 //
84 // ')' not found
85 //
86 return NULL;
87 }
88
89 ParamStr = AllocateCopyPool ((ParameterLength + 1) * sizeof (CHAR16), ParamStr);
90 if (ParamStr == NULL) {
91 return NULL;
92 }
93 //
94 // Terminate the parameter string
95 //
96 ParamStr[ParameterLength] = L'\0';
97
98 return ParamStr;
99}
100
101/**
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"
106
107 @param List A string list separated by the specified separator
108 @param Separator The separator character
109
110 @return A pointer to the current sub-string
111
112**/
113CHAR16 *
114SplitStr (
115 IN OUT CHAR16 **List,
116 IN CHAR16 Separator
117 )
118{
119 CHAR16 *Str;
120 CHAR16 *ReturnStr;
121
122 Str = *List;
123 ReturnStr = Str;
124
125 if (IS_NULL (*Str)) {
126 return ReturnStr;
127 }
128
129 //
130 // Find first occurrence of the separator
131 //
132 while (!IS_NULL (*Str)) {
133 if (*Str == Separator) {
134 break;
135 }
136 Str++;
137 }
138
139 if (*Str == Separator) {
140 //
141 // Find a sub-string, terminate it
142 //
143 *Str = L'\0';
144 Str++;
145 }
146
147 //
148 // Move to next sub-string
149 //
150 *List = Str;
151
152 return ReturnStr;
153}
154
155/**
156 Gets the next parameter string from the list.
157
158 @param List A string list separated by the specified separator
159
160 @return A pointer to the current sub-string
161
162**/
163CHAR16 *
164GetNextParamStr (
165 IN OUT CHAR16 **List
166 )
167{
168 //
169 // The separator is comma
170 //
171 return SplitStr (List, L',');
172}
173
174/**
175 Get one device node from entire device path text.
176
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
179
180 @return A device node text or NULL if no more device node available
181
182**/
183CHAR16 *
184GetNextDeviceNodeStr (
185 IN OUT CHAR16 **DevicePath,
186 OUT BOOLEAN *IsInstanceEnd
187 )
188{
189 CHAR16 *Str;
190 CHAR16 *ReturnStr;
191 UINTN ParenthesesStack;
192
193 Str = *DevicePath;
194 if (IS_NULL (*Str)) {
195 return NULL;
196 }
197
198 //
199 // Skip the leading '/', '(', ')' and ','
200 //
201 while (!IS_NULL (*Str)) {
202 if (!IS_SLASH (*Str) &&
203 !IS_COMMA (*Str) &&
204 !IS_LEFT_PARENTH (*Str) &&
205 !IS_RIGHT_PARENTH (*Str)) {
206 break;
207 }
208 Str++;
209 }
210
211 ReturnStr = Str;
212
213 //
214 // Scan for the separator of this device node, '/' or ','
215 //
216 ParenthesesStack = 0;
217 while (!IS_NULL (*Str)) {
218 if ((IS_COMMA (*Str) || IS_SLASH (*Str)) && (ParenthesesStack == 0)) {
219 break;
220 }
221
222 if (IS_LEFT_PARENTH (*Str)) {
223 ParenthesesStack++;
224 } else if (IS_RIGHT_PARENTH (*Str)) {
225 ParenthesesStack--;
226 }
227
228 Str++;
229 }
230
231 if (ParenthesesStack != 0) {
232 //
233 // The '(' doesn't pair with ')', invalid device path text
234 //
235 return NULL;
236 }
237
238 if (IS_COMMA (*Str)) {
239 *IsInstanceEnd = TRUE;
240 *Str = L'\0';
241 Str++;
242 } else {
243 *IsInstanceEnd = FALSE;
244 if (!IS_NULL (*Str)) {
245 *Str = L'\0';
246 Str++;
247 }
248 }
249
250 *DevicePath = Str;
251
252 return ReturnStr;
253}
254
255
256/**
257 Return whether the integer string is a hex string.
258
259 @param Str The integer string
260
261 @retval TRUE Hex string
262 @retval FALSE Decimal string
263
264**/
265BOOLEAN
266IsHexStr (
267 IN CHAR16 *Str
268 )
269{
270 //
271 // skip preceeding white space
272 //
273 while ((*Str != 0) && *Str == L' ') {
274 Str ++;
275 }
276 //
277 // skip preceeding zeros
278 //
279 while ((*Str != 0) && *Str == L'0') {
280 Str ++;
281 }
282
283 return (BOOLEAN) (*Str == L'x' || *Str == L'X');
284}
285
286/**
287
288 Convert integer string to uint.
289
290 @param Str The integer string. If leading with "0x" or "0X", it's hexadecimal.
291
292 @return A UINTN value represented by Str
293
294**/
295UINTN
296Strtoi (
297 IN CHAR16 *Str
298 )
299{
300 if (IsHexStr (Str)) {
301 return StrHexToUintn (Str);
302 } else {
303 return StrDecimalToUintn (Str);
304 }
305}
306
307/**
308
309 Convert integer string to 64 bit data.
310
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
313
314**/
315VOID
316Strtoi64 (
317 IN CHAR16 *Str,
318 OUT UINT64 *Data
319 )
320{
321 if (IsHexStr (Str)) {
322 *Data = StrHexToUint64 (Str);
323 } else {
324 *Data = StrDecimalToUint64 (Str);
325 }
326}
327
328/**
329 Converts a list of string to a specified buffer.
330
331 @param Buf The output buffer that contains the string.
332 @param BufferLength The length of the buffer
333 @param Str The input string that contains the hex number
334
335 @retval EFI_SUCCESS The string was successfully converted to the buffer.
336
337**/
338EFI_STATUS
339StrToBuf (
340 OUT UINT8 *Buf,
341 IN UINTN BufferLength,
342 IN CHAR16 *Str
343 )
344{
345 UINTN Index;
346 UINTN StrLength;
347 UINT8 Digit;
348 UINT8 Byte;
349
350 Digit = 0;
351
352 //
353 // Two hex char make up one byte
354 //
355 StrLength = BufferLength * sizeof (CHAR16);
356
357 for(Index = 0; Index < StrLength; Index++, Str++) {
358
359 if ((*Str >= L'a') && (*Str <= L'f')) {
360 Digit = (UINT8) (*Str - L'a' + 0x0A);
361 } else if ((*Str >= L'A') && (*Str <= L'F')) {
362 Digit = (UINT8) (*Str - L'A' + 0x0A);
363 } else if ((*Str >= L'0') && (*Str <= L'9')) {
364 Digit = (UINT8) (*Str - L'0');
365 } else {
366 return EFI_INVALID_PARAMETER;
367 }
368
369 //
370 // For odd characters, write the upper nibble for each buffer byte,
371 // and for even characters, the lower nibble.
372 //
373 if ((Index & 1) == 0) {
374 Byte = (UINT8) (Digit << 4);
375 } else {
376 Byte = Buf[Index / 2];
377 Byte &= 0xF0;
378 Byte = (UINT8) (Byte | Digit);
379 }
380
381 Buf[Index / 2] = Byte;
382 }
383
384 return EFI_SUCCESS;
385}
386
387/**
388 Converts a string to GUID value.
389 Guid Format is xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
390
391 @param Str The registry format GUID string that contains the GUID value.
392 @param Guid A pointer to the converted GUID value.
393
394 @retval EFI_SUCCESS The GUID string was successfully converted to the GUID value.
395 @retval EFI_UNSUPPORTED The input string is not in registry format.
396 @return others Some error occurred when converting part of GUID value.
397
398**/
399EFI_STATUS
400StrToGuid (
401 IN CHAR16 *Str,
402 OUT EFI_GUID *Guid
403 )
404{
405 //
406 // Get the first UINT32 data
407 //
408 Guid->Data1 = (UINT32) StrHexToUint64 (Str);
409 while (!IS_HYPHEN (*Str) && !IS_NULL (*Str)) {
410 Str ++;
411 }
412
413 if (IS_HYPHEN (*Str)) {
414 Str++;
415 } else {
416 return EFI_UNSUPPORTED;
417 }
418
419 //
420 // Get the second UINT16 data
421 //
422 Guid->Data2 = (UINT16) StrHexToUint64 (Str);
423 while (!IS_HYPHEN (*Str) && !IS_NULL (*Str)) {
424 Str ++;
425 }
426
427 if (IS_HYPHEN (*Str)) {
428 Str++;
429 } else {
430 return EFI_UNSUPPORTED;
431 }
432
433 //
434 // Get the third UINT16 data
435 //
436 Guid->Data3 = (UINT16) StrHexToUint64 (Str);
437 while (!IS_HYPHEN (*Str) && !IS_NULL (*Str)) {
438 Str ++;
439 }
440
441 if (IS_HYPHEN (*Str)) {
442 Str++;
443 } else {
444 return EFI_UNSUPPORTED;
445 }
446
447 //
448 // Get the following 8 bytes data
449 //
450 StrToBuf (&Guid->Data4[0], 2, Str);
451 //
452 // Skip 2 byte hex chars
453 //
454 Str += 2 * 2;
455
456 if (IS_HYPHEN (*Str)) {
457 Str++;
458 } else {
459 return EFI_UNSUPPORTED;
460 }
461 StrToBuf (&Guid->Data4[2], 6, Str);
462
463 return EFI_SUCCESS;
464}
465
466/**
467 Converts a string to IPv4 address
468
469 @param Str A string representation of IPv4 address.
470 @param IPv4Addr A pointer to the converted IPv4 address.
471
472**/
473VOID
474StrToIPv4Addr (
475 IN OUT CHAR16 **Str,
476 OUT EFI_IPv4_ADDRESS *IPv4Addr
477 )
478{
479 UINTN Index;
480
481 for (Index = 0; Index < 4; Index++) {
482 IPv4Addr->Addr[Index] = (UINT8) Strtoi (SplitStr (Str, L'.'));
483 }
484}
485
486/**
487 Converts a string to IPv4 address
488
489 @param Str A string representation of IPv6 address.
490 @param IPv6Addr A pointer to the converted IPv6 address.
491
492**/
493VOID
494StrToIPv6Addr (
495 IN OUT CHAR16 **Str,
496 OUT EFI_IPv6_ADDRESS *IPv6Addr
497 )
498{
499 UINTN Index;
500 UINT16 Data;
501
502 for (Index = 0; Index < 8; Index++) {
503 Data = (UINT16) StrHexToUintn (SplitStr (Str, L':'));
504 IPv6Addr->Addr[Index * 2] = (UINT8) (Data >> 8);
505 IPv6Addr->Addr[Index * 2 + 1] = (UINT8) (Data & 0xff);
506 }
507}
508
509/**
510 Converts a Unicode string to ASCII string.
511
512 @param Str The equivalent Unicode string
513 @param AsciiStr On input, it points to destination ASCII string buffer; on output, it points
514 to the next ASCII string next to it
515
516**/
517VOID
518StrToAscii (
519 IN CHAR16 *Str,
520 IN OUT CHAR8 **AsciiStr
521 )
522{
523 CHAR8 *Dest;
524
525 Dest = *AsciiStr;
526 while (!IS_NULL (*Str)) {
527 *(Dest++) = (CHAR8) *(Str++);
528 }
529 *Dest = 0;
530
531 //
532 // Return the string next to it
533 //
534 *AsciiStr = Dest + 1;
535}
536
537/**
538 Converts a generic text device path node to device path structure.
539
540 @param Type The type of the device path node.
541 @param TextDeviceNode The input text device path node.
542
543 @return A pointer to device path structure.
544**/
545EFI_DEVICE_PATH_PROTOCOL *
546DevPathFromTextGenericPath (
547 IN UINT8 Type,
548 IN CHAR16 *TextDeviceNode
549 )
550{
551 EFI_DEVICE_PATH_PROTOCOL *Node;
552 CHAR16 *SubtypeStr;
553 CHAR16 *DataStr;
554 UINTN DataLength;
555
556 SubtypeStr = GetNextParamStr (&TextDeviceNode);
557 DataStr = GetNextParamStr (&TextDeviceNode);
558
559 if (DataStr == NULL) {
560 DataLength = 0;
561 } else {
562 DataLength = StrLen (DataStr) / 2;
563 }
564 Node = CreateDeviceNode (
565 Type,
566 (UINT8) Strtoi (SubtypeStr),
567 (UINT16) (sizeof (EFI_DEVICE_PATH_PROTOCOL) + DataLength)
568 );
569
570 if (DataLength != 0) {
571 StrToBuf ((UINT8 *) (Node + 1), DataLength, DataStr);
572 }
573 return Node;
574}
575
576/**
577 Converts a generic text device path node to device path structure.
578
579 @param TextDeviceNode The input Text device path node.
580
581 @return A pointer to device path structure.
582
583**/
584EFI_DEVICE_PATH_PROTOCOL *
585DevPathFromTextPath (
586 IN CHAR16 *TextDeviceNode
587 )
588{
589 CHAR16 *TypeStr;
590
591 TypeStr = GetNextParamStr (&TextDeviceNode);
592
593 return DevPathFromTextGenericPath ((UINT8) Strtoi (TypeStr), TextDeviceNode);
594}
595
596/**
597 Converts a generic hardware text device path node to Hardware device path structure.
598
599 @param TextDeviceNode The input Text device path node.
600
601 @return A pointer to Hardware device path structure.
602
603**/
604EFI_DEVICE_PATH_PROTOCOL *
605DevPathFromTextHardwarePath (
606 IN CHAR16 *TextDeviceNode
607 )
608{
609 return DevPathFromTextGenericPath (HARDWARE_DEVICE_PATH, TextDeviceNode);
610}
611
612/**
613 Converts a text device path node to Hardware PCI device path structure.
614
615 @param TextDeviceNode The input Text device path node.
616
617 @return A pointer to Hardware PCI device path structure.
618
619**/
620EFI_DEVICE_PATH_PROTOCOL *
621DevPathFromTextPci (
622 IN CHAR16 *TextDeviceNode
623 )
624{
625 CHAR16 *FunctionStr;
626 CHAR16 *DeviceStr;
627 PCI_DEVICE_PATH *Pci;
628
629 DeviceStr = GetNextParamStr (&TextDeviceNode);
630 FunctionStr = GetNextParamStr (&TextDeviceNode);
631 Pci = (PCI_DEVICE_PATH *) CreateDeviceNode (
632 HARDWARE_DEVICE_PATH,
633 HW_PCI_DP,
634 (UINT16) sizeof (PCI_DEVICE_PATH)
635 );
636
637 Pci->Function = (UINT8) Strtoi (FunctionStr);
638 Pci->Device = (UINT8) Strtoi (DeviceStr);
639
640 return (EFI_DEVICE_PATH_PROTOCOL *) Pci;
641}
642
643/**
644 Converts a text device path node to Hardware PC card device path structure.
645
646 @param TextDeviceNode The input Text device path node.
647
648 @return A pointer to Hardware PC card device path structure.
649
650**/
651EFI_DEVICE_PATH_PROTOCOL *
652DevPathFromTextPcCard (
653 IN CHAR16 *TextDeviceNode
654 )
655{
656 CHAR16 *FunctionNumberStr;
657 PCCARD_DEVICE_PATH *Pccard;
658
659 FunctionNumberStr = GetNextParamStr (&TextDeviceNode);
660 Pccard = (PCCARD_DEVICE_PATH *) CreateDeviceNode (
661 HARDWARE_DEVICE_PATH,
662 HW_PCCARD_DP,
663 (UINT16) sizeof (PCCARD_DEVICE_PATH)
664 );
665
666 Pccard->FunctionNumber = (UINT8) Strtoi (FunctionNumberStr);
667
668 return (EFI_DEVICE_PATH_PROTOCOL *) Pccard;
669}
670
671/**
672 Converts a text device path node to Hardware memory map device path structure.
673
674 @param TextDeviceNode The input Text device path node.
675
676 @return A pointer to Hardware memory map device path structure.
677
678**/
679EFI_DEVICE_PATH_PROTOCOL *
680DevPathFromTextMemoryMapped (
681 IN CHAR16 *TextDeviceNode
682 )
683{
684 CHAR16 *MemoryTypeStr;
685 CHAR16 *StartingAddressStr;
686 CHAR16 *EndingAddressStr;
687 MEMMAP_DEVICE_PATH *MemMap;
688
689 MemoryTypeStr = GetNextParamStr (&TextDeviceNode);
690 StartingAddressStr = GetNextParamStr (&TextDeviceNode);
691 EndingAddressStr = GetNextParamStr (&TextDeviceNode);
692 MemMap = (MEMMAP_DEVICE_PATH *) CreateDeviceNode (
693 HARDWARE_DEVICE_PATH,
694 HW_MEMMAP_DP,
695 (UINT16) sizeof (MEMMAP_DEVICE_PATH)
696 );
697
698 MemMap->MemoryType = (UINT32) Strtoi (MemoryTypeStr);
699 Strtoi64 (StartingAddressStr, &MemMap->StartingAddress);
700 Strtoi64 (EndingAddressStr, &MemMap->EndingAddress);
701
702 return (EFI_DEVICE_PATH_PROTOCOL *) MemMap;
703}
704
705/**
706 Converts a text device path node to Vendor device path structure based on the input Type
707 and SubType.
708
709 @param TextDeviceNode The input Text device path node.
710 @param Type The type of device path node.
711 @param SubType The subtype of device path node.
712
713 @return A pointer to the newly-created Vendor device path structure.
714
715**/
716EFI_DEVICE_PATH_PROTOCOL *
717ConvertFromTextVendor (
718 IN CHAR16 *TextDeviceNode,
719 IN UINT8 Type,
720 IN UINT8 SubType
721 )
722{
723 CHAR16 *GuidStr;
724 CHAR16 *DataStr;
725 UINTN Length;
726 VENDOR_DEVICE_PATH *Vendor;
727
728 GuidStr = GetNextParamStr (&TextDeviceNode);
729
730 DataStr = GetNextParamStr (&TextDeviceNode);
731 Length = StrLen (DataStr);
732 //
733 // Two hex characters make up 1 buffer byte
734 //
735 Length = (Length + 1) / 2;
736
737 Vendor = (VENDOR_DEVICE_PATH *) CreateDeviceNode (
738 Type,
739 SubType,
740 (UINT16) (sizeof (VENDOR_DEVICE_PATH) + Length)
741 );
742
743 StrToGuid (GuidStr, &Vendor->Guid);
744 StrToBuf (((UINT8 *) Vendor) + sizeof (VENDOR_DEVICE_PATH), Length, DataStr);
745
746 return (EFI_DEVICE_PATH_PROTOCOL *) Vendor;
747}
748
749/**
750 Converts a text device path node to Vendor Hardware device path structure.
751
752 @param TextDeviceNode The input Text device path node.
753
754 @return A pointer to the newly-created Vendor Hardware device path structure.
755
756**/
757EFI_DEVICE_PATH_PROTOCOL *
758DevPathFromTextVenHw (
759 IN CHAR16 *TextDeviceNode
760 )
761{
762 return ConvertFromTextVendor (
763 TextDeviceNode,
764 HARDWARE_DEVICE_PATH,
765 HW_VENDOR_DP
766 );
767}
768
769/**
770 Converts a text device path node to Hardware Controller device path structure.
771
772 @param TextDeviceNode The input Text device path node.
773
774 @return A pointer to the newly-created Hardware Controller device path structure.
775
776**/
777EFI_DEVICE_PATH_PROTOCOL *
778DevPathFromTextCtrl (
779 IN CHAR16 *TextDeviceNode
780 )
781{
782 CHAR16 *ControllerStr;
783 CONTROLLER_DEVICE_PATH *Controller;
784
785 ControllerStr = GetNextParamStr (&TextDeviceNode);
786 Controller = (CONTROLLER_DEVICE_PATH *) CreateDeviceNode (
787 HARDWARE_DEVICE_PATH,
788 HW_CONTROLLER_DP,
789 (UINT16) sizeof (CONTROLLER_DEVICE_PATH)
790 );
791 Controller->ControllerNumber = (UINT32) Strtoi (ControllerStr);
792
793 return (EFI_DEVICE_PATH_PROTOCOL *) Controller;
794}
795
796/**
797 Converts a generic ACPI text device path node to ACPI device path structure.
798
799 @param TextDeviceNode The input Text device path node.
800
801 @return A pointer to ACPI device path structure.
802
803**/
804EFI_DEVICE_PATH_PROTOCOL *
805DevPathFromTextAcpiPath (
806 IN CHAR16 *TextDeviceNode
807 )
808{
809 return DevPathFromTextGenericPath (ACPI_DEVICE_PATH, TextDeviceNode);
810}
811
812/**
813 Converts a string to EisaId.
814
815 @param Text The input string.
816
817 @return UINT32 EISA ID.
818**/
819UINT32
820EisaIdFromText (
821 IN CHAR16 *Text
822 )
823{
824 return (((Text[0] - 'A' + 1) & 0x1f) << 10)
825 + (((Text[1] - 'A' + 1) & 0x1f) << 5)
826 + (((Text[2] - 'A' + 1) & 0x1f) << 0)
827 + (UINT32) (StrHexToUintn (&Text[3]) << 16)
828 ;
829}
830
831/**
832 Converts a text device path node to ACPI HID device path structure.
833
834 @param TextDeviceNode The input Text device path node.
835
836 @return A pointer to the newly-created ACPI HID device path structure.
837
838**/
839EFI_DEVICE_PATH_PROTOCOL *
840DevPathFromTextAcpi (
841 IN CHAR16 *TextDeviceNode
842 )
843{
844 CHAR16 *HIDStr;
845 CHAR16 *UIDStr;
846 ACPI_HID_DEVICE_PATH *Acpi;
847
848 HIDStr = GetNextParamStr (&TextDeviceNode);
849 UIDStr = GetNextParamStr (&TextDeviceNode);
850 Acpi = (ACPI_HID_DEVICE_PATH *) CreateDeviceNode (
851 ACPI_DEVICE_PATH,
852 ACPI_DP,
853 (UINT16) sizeof (ACPI_HID_DEVICE_PATH)
854 );
855
856 Acpi->HID = EisaIdFromText (HIDStr);
857 Acpi->UID = (UINT32) Strtoi (UIDStr);
858
859 return (EFI_DEVICE_PATH_PROTOCOL *) Acpi;
860}
861
862/**
863 Converts a text device path node to ACPI HID device path structure.
864
865 @param TextDeviceNode The input Text device path node.
866 @param PnPId The input plug and play identification.
867
868 @return A pointer to the newly-created ACPI HID device path structure.
869
870**/
871EFI_DEVICE_PATH_PROTOCOL *
872ConvertFromTextAcpi (
873 IN CHAR16 *TextDeviceNode,
874 IN UINT32 PnPId
875 )
876{
877 CHAR16 *UIDStr;
878 ACPI_HID_DEVICE_PATH *Acpi;
879
880 UIDStr = GetNextParamStr (&TextDeviceNode);
881 Acpi = (ACPI_HID_DEVICE_PATH *) CreateDeviceNode (
882 ACPI_DEVICE_PATH,
883 ACPI_DP,
884 (UINT16) sizeof (ACPI_HID_DEVICE_PATH)
885 );
886
887 Acpi->HID = EFI_PNP_ID (PnPId);
888 Acpi->UID = (UINT32) Strtoi (UIDStr);
889
890 return (EFI_DEVICE_PATH_PROTOCOL *) Acpi;
891}
892
893/**
894 Converts a text device path node to PCI root device path structure.
895
896 @param TextDeviceNode The input Text device path node.
897
898 @return A pointer to the newly-created PCI root device path structure.
899
900**/
901EFI_DEVICE_PATH_PROTOCOL *
902DevPathFromTextPciRoot (
903 IN CHAR16 *TextDeviceNode
904 )
905{
906 return ConvertFromTextAcpi (TextDeviceNode, 0x0a03);
907}
908
909/**
910 Converts a text device path node to PCIE root device path structure.
911
912 @param TextDeviceNode The input Text device path node.
913
914 @return A pointer to the newly-created PCIE root device path structure.
915
916**/
917EFI_DEVICE_PATH_PROTOCOL *
918DevPathFromTextPcieRoot (
919 IN CHAR16 *TextDeviceNode
920 )
921{
922 return ConvertFromTextAcpi (TextDeviceNode, 0x0a08);
923}
924
925/**
926 Converts a text device path node to Floppy device path structure.
927
928 @param TextDeviceNode The input Text device path node.
929
930 @return A pointer to the newly-created Floppy device path structure.
931
932**/
933EFI_DEVICE_PATH_PROTOCOL *
934DevPathFromTextFloppy (
935 IN CHAR16 *TextDeviceNode
936 )
937{
938 return ConvertFromTextAcpi (TextDeviceNode, 0x0604);
939}
940
941/**
942 Converts a text device path node to Keyboard device path structure.
943
944 @param TextDeviceNode The input Text device path node.
945
946 @return A pointer to the newly-created Keyboard device path structure.
947
948**/
949EFI_DEVICE_PATH_PROTOCOL *
950DevPathFromTextKeyboard (
951 IN CHAR16 *TextDeviceNode
952 )
953{
954 return ConvertFromTextAcpi (TextDeviceNode, 0x0301);
955}
956
957/**
958 Converts a text device path node to Serial device path structure.
959
960 @param TextDeviceNode The input Text device path node.
961
962 @return A pointer to the newly-created Serial device path structure.
963
964**/
965EFI_DEVICE_PATH_PROTOCOL *
966DevPathFromTextSerial (
967 IN CHAR16 *TextDeviceNode
968 )
969{
970 return ConvertFromTextAcpi (TextDeviceNode, 0x0501);
971}
972
973/**
974 Converts a text device path node to Parallel Port device path structure.
975
976 @param TextDeviceNode The input Text device path node.
977
978 @return A pointer to the newly-created Parallel Port device path structure.
979
980**/
981EFI_DEVICE_PATH_PROTOCOL *
982DevPathFromTextParallelPort (
983 IN CHAR16 *TextDeviceNode
984 )
985{
986 return ConvertFromTextAcpi (TextDeviceNode, 0x0401);
987}
988
989/**
990 Converts a text device path node to ACPI extension device path structure.
991
992 @param TextDeviceNode The input Text device path node.
993
994 @return A pointer to the newly-created ACPI extension device path structure.
995
996**/
997EFI_DEVICE_PATH_PROTOCOL *
998DevPathFromTextAcpiEx (
999 IN CHAR16 *TextDeviceNode
1000 )
1001{
1002 CHAR16 *HIDStr;
1003 CHAR16 *CIDStr;
1004 CHAR16 *UIDStr;
1005 CHAR16 *HIDSTRStr;
1006 CHAR16 *CIDSTRStr;
1007 CHAR16 *UIDSTRStr;
1008 CHAR8 *AsciiStr;
1009 UINT16 Length;
1010 ACPI_EXTENDED_HID_DEVICE_PATH *AcpiEx;
1011
1012 HIDStr = GetNextParamStr (&TextDeviceNode);
1013 CIDStr = GetNextParamStr (&TextDeviceNode);
1014 UIDStr = GetNextParamStr (&TextDeviceNode);
1015 HIDSTRStr = GetNextParamStr (&TextDeviceNode);
1016 CIDSTRStr = GetNextParamStr (&TextDeviceNode);
1017 UIDSTRStr = GetNextParamStr (&TextDeviceNode);
1018
1019 Length = (UINT16) (sizeof (ACPI_EXTENDED_HID_DEVICE_PATH) + StrLen (HIDSTRStr) + 1);
1020 Length = (UINT16) (Length + StrLen (UIDSTRStr) + 1);
1021 Length = (UINT16) (Length + StrLen (CIDSTRStr) + 1);
1022 AcpiEx = (ACPI_EXTENDED_HID_DEVICE_PATH *) CreateDeviceNode (
1023 ACPI_DEVICE_PATH,
1024 ACPI_EXTENDED_DP,
1025 Length
1026 );
1027
1028 AcpiEx->HID = EisaIdFromText (HIDStr);
1029 AcpiEx->CID = EisaIdFromText (CIDStr);
1030 AcpiEx->UID = (UINT32) Strtoi (UIDStr);
1031
1032 AsciiStr = (CHAR8 *) ((UINT8 *)AcpiEx + sizeof (ACPI_EXTENDED_HID_DEVICE_PATH));
1033 StrToAscii (HIDSTRStr, &AsciiStr);
1034 StrToAscii (UIDSTRStr, &AsciiStr);
1035 StrToAscii (CIDSTRStr, &AsciiStr);
1036
1037 return (EFI_DEVICE_PATH_PROTOCOL *) AcpiEx;
1038}
1039
1040/**
1041 Converts a text device path node to ACPI extension device path structure.
1042
1043 @param TextDeviceNode The input Text device path node.
1044
1045 @return A pointer to the newly-created ACPI extension device path structure.
1046
1047**/
1048EFI_DEVICE_PATH_PROTOCOL *
1049DevPathFromTextAcpiExp (
1050 IN CHAR16 *TextDeviceNode
1051 )
1052{
1053 CHAR16 *HIDStr;
1054 CHAR16 *CIDStr;
1055 CHAR16 *UIDSTRStr;
1056 CHAR8 *AsciiStr;
1057 UINT16 Length;
1058 ACPI_EXTENDED_HID_DEVICE_PATH *AcpiEx;
1059
1060 HIDStr = GetNextParamStr (&TextDeviceNode);
1061 CIDStr = GetNextParamStr (&TextDeviceNode);
1062 UIDSTRStr = GetNextParamStr (&TextDeviceNode);
1063 Length = (UINT16) (sizeof (ACPI_EXTENDED_HID_DEVICE_PATH) + StrLen (UIDSTRStr) + 3);
1064 AcpiEx = (ACPI_EXTENDED_HID_DEVICE_PATH *) CreateDeviceNode (
1065 ACPI_DEVICE_PATH,
1066 ACPI_EXTENDED_DP,
1067 Length
1068 );
1069
1070 AcpiEx->HID = EisaIdFromText (HIDStr);
1071 AcpiEx->CID = EisaIdFromText (CIDStr);
1072 AcpiEx->UID = 0;
1073
1074 AsciiStr = (CHAR8 *) ((UINT8 *)AcpiEx + sizeof (ACPI_EXTENDED_HID_DEVICE_PATH));
1075 //
1076 // HID string is NULL
1077 //
1078 *AsciiStr = '\0';
1079 //
1080 // Convert UID string
1081 //
1082 AsciiStr++;
1083 StrToAscii (UIDSTRStr, &AsciiStr);
1084 //
1085 // CID string is NULL
1086 //
1087 *AsciiStr = '\0';
1088
1089 return (EFI_DEVICE_PATH_PROTOCOL *) AcpiEx;
1090}
1091
1092/**
1093 Converts a text device path node to ACPI _ADR device path structure.
1094
1095 @param TextDeviceNode The input Text device path node.
1096
1097 @return A pointer to the newly-created ACPI _ADR device path structure.
1098
1099**/
1100EFI_DEVICE_PATH_PROTOCOL *
1101DevPathFromTextAcpiAdr (
1102 IN CHAR16 *TextDeviceNode
1103 )
1104{
1105 CHAR16 *DisplayDeviceStr;
1106 ACPI_ADR_DEVICE_PATH *AcpiAdr;
1107 UINTN Index;
1108 UINTN Length;
1109
1110 AcpiAdr = (ACPI_ADR_DEVICE_PATH *) CreateDeviceNode (
1111 ACPI_DEVICE_PATH,
1112 ACPI_ADR_DP,
1113 (UINT16) sizeof (ACPI_ADR_DEVICE_PATH)
1114 );
1115 ASSERT (AcpiAdr != NULL);
1116
1117 for (Index = 0; ; Index++) {
1118 DisplayDeviceStr = GetNextParamStr (&TextDeviceNode);
1119 if (IS_NULL (*DisplayDeviceStr)) {
1120 break;
1121 }
1122 if (Index > 0) {
1123 Length = DevicePathNodeLength (AcpiAdr);
1124 AcpiAdr = ReallocatePool (
1125 Length,
1126 Length + sizeof (UINT32),
1127 AcpiAdr
1128 );
1129 ASSERT (AcpiAdr != NULL);
1130 SetDevicePathNodeLength (AcpiAdr, Length + sizeof (UINT32));
1131 }
1132
1133 (&AcpiAdr->ADR)[Index] = (UINT32) Strtoi (DisplayDeviceStr);
1134 }
1135
1136 return (EFI_DEVICE_PATH_PROTOCOL *) AcpiAdr;
1137}
1138
1139/**
1140 Converts a generic messaging text device path node to messaging device path structure.
1141
1142 @param TextDeviceNode The input Text device path node.
1143
1144 @return A pointer to messaging device path structure.
1145
1146**/
1147EFI_DEVICE_PATH_PROTOCOL *
1148DevPathFromTextMsg (
1149 IN CHAR16 *TextDeviceNode
1150 )
1151{
1152 return DevPathFromTextGenericPath (MESSAGING_DEVICE_PATH, TextDeviceNode);
1153}
1154
1155/**
1156 Converts a text device path node to Parallel Port device path structure.
1157
1158 @param TextDeviceNode The input Text device path node.
1159
1160 @return A pointer to the newly-created Parallel Port device path structure.
1161
1162**/
1163EFI_DEVICE_PATH_PROTOCOL *
1164DevPathFromTextAta (
1165IN CHAR16 *TextDeviceNode
1166)
1167{
1168 CHAR16 *PrimarySecondaryStr;
1169 CHAR16 *SlaveMasterStr;
1170 CHAR16 *LunStr;
1171 ATAPI_DEVICE_PATH *Atapi;
1172
1173 Atapi = (ATAPI_DEVICE_PATH *) CreateDeviceNode (
1174 MESSAGING_DEVICE_PATH,
1175 MSG_ATAPI_DP,
1176 (UINT16) sizeof (ATAPI_DEVICE_PATH)
1177 );
1178
1179 PrimarySecondaryStr = GetNextParamStr (&TextDeviceNode);
1180 SlaveMasterStr = GetNextParamStr (&TextDeviceNode);
1181 LunStr = GetNextParamStr (&TextDeviceNode);
1182
1183 if (StrCmp (PrimarySecondaryStr, L"Primary") == 0) {
1184 Atapi->PrimarySecondary = 0;
1185 } else if (StrCmp (PrimarySecondaryStr, L"Secondary") == 0) {
1186 Atapi->PrimarySecondary = 1;
1187 } else {
1188 Atapi->PrimarySecondary = (UINT8) Strtoi (PrimarySecondaryStr);
1189 }
1190 if (StrCmp (SlaveMasterStr, L"Master") == 0) {
1191 Atapi->SlaveMaster = 0;
1192 } else if (StrCmp (SlaveMasterStr, L"Slave") == 0) {
1193 Atapi->SlaveMaster = 1;
1194 } else {
1195 Atapi->SlaveMaster = (UINT8) Strtoi (SlaveMasterStr);
1196 }
1197
1198 Atapi->Lun = (UINT16) Strtoi (LunStr);
1199
1200 return (EFI_DEVICE_PATH_PROTOCOL *) Atapi;
1201}
1202
1203/**
1204 Converts a text device path node to SCSI device path structure.
1205
1206 @param TextDeviceNode The input Text device path node.
1207
1208 @return A pointer to the newly-created SCSI device path structure.
1209
1210**/
1211EFI_DEVICE_PATH_PROTOCOL *
1212DevPathFromTextScsi (
1213 IN CHAR16 *TextDeviceNode
1214 )
1215{
1216 CHAR16 *PunStr;
1217 CHAR16 *LunStr;
1218 SCSI_DEVICE_PATH *Scsi;
1219
1220 PunStr = GetNextParamStr (&TextDeviceNode);
1221 LunStr = GetNextParamStr (&TextDeviceNode);
1222 Scsi = (SCSI_DEVICE_PATH *) CreateDeviceNode (
1223 MESSAGING_DEVICE_PATH,
1224 MSG_SCSI_DP,
1225 (UINT16) sizeof (SCSI_DEVICE_PATH)
1226 );
1227
1228 Scsi->Pun = (UINT16) Strtoi (PunStr);
1229 Scsi->Lun = (UINT16) Strtoi (LunStr);
1230
1231 return (EFI_DEVICE_PATH_PROTOCOL *) Scsi;
1232}
1233
1234/**
1235 Converts a text device path node to Fibre device path structure.
1236
1237 @param TextDeviceNode The input Text device path node.
1238
1239 @return A pointer to the newly-created Fibre device path structure.
1240
1241**/
1242EFI_DEVICE_PATH_PROTOCOL *
1243DevPathFromTextFibre (
1244 IN CHAR16 *TextDeviceNode
1245 )
1246{
1247 CHAR16 *WWNStr;
1248 CHAR16 *LunStr;
1249 FIBRECHANNEL_DEVICE_PATH *Fibre;
1250
1251 WWNStr = GetNextParamStr (&TextDeviceNode);
1252 LunStr = GetNextParamStr (&TextDeviceNode);
1253 Fibre = (FIBRECHANNEL_DEVICE_PATH *) CreateDeviceNode (
1254 MESSAGING_DEVICE_PATH,
1255 MSG_FIBRECHANNEL_DP,
1256 (UINT16) sizeof (FIBRECHANNEL_DEVICE_PATH)
1257 );
1258
1259 Fibre->Reserved = 0;
1260 Strtoi64 (WWNStr, &Fibre->WWN);
1261 Strtoi64 (LunStr, &Fibre->Lun);
1262
1263 return (EFI_DEVICE_PATH_PROTOCOL *) Fibre;
1264}
1265
1266/**
1267 Converts a text device path node to FibreEx device path structure.
1268
1269 @param TextDeviceNode The input Text device path node.
1270
1271 @return A pointer to the newly-created FibreEx device path structure.
1272
1273**/
1274EFI_DEVICE_PATH_PROTOCOL *
1275DevPathFromTextFibreEx (
1276 IN CHAR16 *TextDeviceNode
1277 )
1278{
1279 CHAR16 *WWNStr;
1280 CHAR16 *LunStr;
1281 FIBRECHANNELEX_DEVICE_PATH *FibreEx;
1282
1283 WWNStr = GetNextParamStr (&TextDeviceNode);
1284 LunStr = GetNextParamStr (&TextDeviceNode);
1285 FibreEx = (FIBRECHANNELEX_DEVICE_PATH *) CreateDeviceNode (
1286 MESSAGING_DEVICE_PATH,
1287 MSG_FIBRECHANNELEX_DP,
1288 (UINT16) sizeof (FIBRECHANNELEX_DEVICE_PATH)
1289 );
1290
1291 FibreEx->Reserved = 0;
1292 Strtoi64 (WWNStr, (UINT64 *) (&FibreEx->WWN));
1293 Strtoi64 (LunStr, (UINT64 *) (&FibreEx->Lun));
1294
1295 *(UINT64 *) (&FibreEx->WWN) = SwapBytes64 (*(UINT64 *) (&FibreEx->WWN));
1296 *(UINT64 *) (&FibreEx->Lun) = SwapBytes64 (*(UINT64 *) (&FibreEx->Lun));
1297
1298 return (EFI_DEVICE_PATH_PROTOCOL *) FibreEx;
1299}
1300
1301/**
1302 Converts a text device path node to 1394 device path structure.
1303
1304 @param TextDeviceNode The input Text device path node.
1305
1306 @return A pointer to the newly-created 1394 device path structure.
1307
1308**/
1309EFI_DEVICE_PATH_PROTOCOL *
1310DevPathFromText1394 (
1311 IN CHAR16 *TextDeviceNode
1312 )
1313{
1314 CHAR16 *GuidStr;
1315 F1394_DEVICE_PATH *F1394DevPath;
1316
1317 GuidStr = GetNextParamStr (&TextDeviceNode);
1318 F1394DevPath = (F1394_DEVICE_PATH *) CreateDeviceNode (
1319 MESSAGING_DEVICE_PATH,
1320 MSG_1394_DP,
1321 (UINT16) sizeof (F1394_DEVICE_PATH)
1322 );
1323
1324 F1394DevPath->Reserved = 0;
1325 F1394DevPath->Guid = StrHexToUint64 (GuidStr);
1326
1327 return (EFI_DEVICE_PATH_PROTOCOL *) F1394DevPath;
1328}
1329
1330/**
1331 Converts a text device path node to USB device path structure.
1332
1333 @param TextDeviceNode The input Text device path node.
1334
1335 @return A pointer to the newly-created USB device path structure.
1336
1337**/
1338EFI_DEVICE_PATH_PROTOCOL *
1339DevPathFromTextUsb (
1340 IN CHAR16 *TextDeviceNode
1341 )
1342{
1343 CHAR16 *PortStr;
1344 CHAR16 *InterfaceStr;
1345 USB_DEVICE_PATH *Usb;
1346
1347 PortStr = GetNextParamStr (&TextDeviceNode);
1348 InterfaceStr = GetNextParamStr (&TextDeviceNode);
1349 Usb = (USB_DEVICE_PATH *) CreateDeviceNode (
1350 MESSAGING_DEVICE_PATH,
1351 MSG_USB_DP,
1352 (UINT16) sizeof (USB_DEVICE_PATH)
1353 );
1354
1355 Usb->ParentPortNumber = (UINT8) Strtoi (PortStr);
1356 Usb->InterfaceNumber = (UINT8) Strtoi (InterfaceStr);
1357
1358 return (EFI_DEVICE_PATH_PROTOCOL *) Usb;
1359}
1360
1361/**
1362 Converts a text device path node to I20 device path structure.
1363
1364 @param TextDeviceNode The input Text device path node.
1365
1366 @return A pointer to the newly-created I20 device path structure.
1367
1368**/
1369EFI_DEVICE_PATH_PROTOCOL *
1370DevPathFromTextI2O (
1371 IN CHAR16 *TextDeviceNode
1372 )
1373{
1374 CHAR16 *TIDStr;
1375 I2O_DEVICE_PATH *I2ODevPath;
1376
1377 TIDStr = GetNextParamStr (&TextDeviceNode);
1378 I2ODevPath = (I2O_DEVICE_PATH *) CreateDeviceNode (
1379 MESSAGING_DEVICE_PATH,
1380 MSG_I2O_DP,
1381 (UINT16) sizeof (I2O_DEVICE_PATH)
1382 );
1383
1384 I2ODevPath->Tid = (UINT32) Strtoi (TIDStr);
1385
1386 return (EFI_DEVICE_PATH_PROTOCOL *) I2ODevPath;
1387}
1388
1389/**
1390 Converts a text device path node to Infini Band device path structure.
1391
1392 @param TextDeviceNode The input Text device path node.
1393
1394 @return A pointer to the newly-created Infini Band device path structure.
1395
1396**/
1397EFI_DEVICE_PATH_PROTOCOL *
1398DevPathFromTextInfiniband (
1399 IN CHAR16 *TextDeviceNode
1400 )
1401{
1402 CHAR16 *FlagsStr;
1403 CHAR16 *GuidStr;
1404 CHAR16 *SidStr;
1405 CHAR16 *TidStr;
1406 CHAR16 *DidStr;
1407 EFI_GUID PortGid;
1408 INFINIBAND_DEVICE_PATH *InfiniBand;
1409
1410 FlagsStr = GetNextParamStr (&TextDeviceNode);
1411 GuidStr = GetNextParamStr (&TextDeviceNode);
1412 SidStr = GetNextParamStr (&TextDeviceNode);
1413 TidStr = GetNextParamStr (&TextDeviceNode);
1414 DidStr = GetNextParamStr (&TextDeviceNode);
1415 InfiniBand = (INFINIBAND_DEVICE_PATH *) CreateDeviceNode (
1416 MESSAGING_DEVICE_PATH,
1417 MSG_INFINIBAND_DP,
1418 (UINT16) sizeof (INFINIBAND_DEVICE_PATH)
1419 );
1420
1421 InfiniBand->ResourceFlags = (UINT32) Strtoi (FlagsStr);
1422 StrToGuid (GuidStr, &PortGid);
1423 CopyMem (InfiniBand->PortGid, &PortGid, sizeof (EFI_GUID));
1424 Strtoi64 (SidStr, &InfiniBand->ServiceId);
1425 Strtoi64 (TidStr, &InfiniBand->TargetPortId);
1426 Strtoi64 (DidStr, &InfiniBand->DeviceId);
1427
1428 return (EFI_DEVICE_PATH_PROTOCOL *) InfiniBand;
1429}
1430
1431/**
1432 Converts a text device path node to Vendor-Defined Messaging device path structure.
1433
1434 @param TextDeviceNode The input Text device path node.
1435
1436 @return A pointer to the newly-created Vendor-Defined Messaging device path structure.
1437
1438**/
1439EFI_DEVICE_PATH_PROTOCOL *
1440DevPathFromTextVenMsg (
1441 IN CHAR16 *TextDeviceNode
1442 )
1443{
1444 return ConvertFromTextVendor (
1445 TextDeviceNode,
1446 MESSAGING_DEVICE_PATH,
1447 MSG_VENDOR_DP
1448 );
1449}
1450
1451/**
1452 Converts a text device path node to Vendor defined PC-ANSI device path structure.
1453
1454 @param TextDeviceNode The input Text device path node.
1455
1456 @return A pointer to the newly-created Vendor defined PC-ANSI device path structure.
1457
1458**/
1459EFI_DEVICE_PATH_PROTOCOL *
1460DevPathFromTextVenPcAnsi (
1461 IN CHAR16 *TextDeviceNode
1462 )
1463{
1464 VENDOR_DEVICE_PATH *Vendor;
1465
1466 Vendor = (VENDOR_DEVICE_PATH *) CreateDeviceNode (
1467 MESSAGING_DEVICE_PATH,
1468 MSG_VENDOR_DP,
1469 (UINT16) sizeof (VENDOR_DEVICE_PATH));
1470 CopyGuid (&Vendor->Guid, &gEfiPcAnsiGuid);
1471
1472 return (EFI_DEVICE_PATH_PROTOCOL *) Vendor;
1473}
1474
1475/**
1476 Converts a text device path node to Vendor defined VT100 device path structure.
1477
1478 @param TextDeviceNode The input Text device path node.
1479
1480 @return A pointer to the newly-created Vendor defined VT100 device path structure.
1481
1482**/
1483EFI_DEVICE_PATH_PROTOCOL *
1484DevPathFromTextVenVt100 (
1485 IN CHAR16 *TextDeviceNode
1486 )
1487{
1488 VENDOR_DEVICE_PATH *Vendor;
1489
1490 Vendor = (VENDOR_DEVICE_PATH *) CreateDeviceNode (
1491 MESSAGING_DEVICE_PATH,
1492 MSG_VENDOR_DP,
1493 (UINT16) sizeof (VENDOR_DEVICE_PATH));
1494 CopyGuid (&Vendor->Guid, &gEfiVT100Guid);
1495
1496 return (EFI_DEVICE_PATH_PROTOCOL *) Vendor;
1497}
1498
1499/**
1500 Converts a text device path node to Vendor defined VT100 Plus device path structure.
1501
1502 @param TextDeviceNode The input Text device path node.
1503
1504 @return A pointer to the newly-created Vendor defined VT100 Plus device path structure.
1505
1506**/
1507EFI_DEVICE_PATH_PROTOCOL *
1508DevPathFromTextVenVt100Plus (
1509 IN CHAR16 *TextDeviceNode
1510 )
1511{
1512 VENDOR_DEVICE_PATH *Vendor;
1513
1514 Vendor = (VENDOR_DEVICE_PATH *) CreateDeviceNode (
1515 MESSAGING_DEVICE_PATH,
1516 MSG_VENDOR_DP,
1517 (UINT16) sizeof (VENDOR_DEVICE_PATH));
1518 CopyGuid (&Vendor->Guid, &gEfiVT100PlusGuid);
1519
1520 return (EFI_DEVICE_PATH_PROTOCOL *) Vendor;
1521}
1522
1523/**
1524 Converts a text device path node to Vendor defined UTF8 device path structure.
1525
1526 @param TextDeviceNode The input Text device path node.
1527
1528 @return A pointer to the newly-created Vendor defined UTF8 device path structure.
1529
1530**/
1531EFI_DEVICE_PATH_PROTOCOL *
1532DevPathFromTextVenUtf8 (
1533 IN CHAR16 *TextDeviceNode
1534 )
1535{
1536 VENDOR_DEVICE_PATH *Vendor;
1537
1538 Vendor = (VENDOR_DEVICE_PATH *) CreateDeviceNode (
1539 MESSAGING_DEVICE_PATH,
1540 MSG_VENDOR_DP,
1541 (UINT16) sizeof (VENDOR_DEVICE_PATH));
1542 CopyGuid (&Vendor->Guid, &gEfiVTUTF8Guid);
1543
1544 return (EFI_DEVICE_PATH_PROTOCOL *) Vendor;
1545}
1546
1547/**
1548 Converts a text device path node to UART Flow Control device path structure.
1549
1550 @param TextDeviceNode The input Text device path node.
1551
1552 @return A pointer to the newly-created UART Flow Control device path structure.
1553
1554**/
1555EFI_DEVICE_PATH_PROTOCOL *
1556DevPathFromTextUartFlowCtrl (
1557 IN CHAR16 *TextDeviceNode
1558 )
1559{
1560 CHAR16 *ValueStr;
1561 UART_FLOW_CONTROL_DEVICE_PATH *UartFlowControl;
1562
1563 ValueStr = GetNextParamStr (&TextDeviceNode);
1564 UartFlowControl = (UART_FLOW_CONTROL_DEVICE_PATH *) CreateDeviceNode (
1565 MESSAGING_DEVICE_PATH,
1566 MSG_VENDOR_DP,
1567 (UINT16) sizeof (UART_FLOW_CONTROL_DEVICE_PATH)
1568 );
1569
1570 CopyGuid (&UartFlowControl->Guid, &gEfiUartDevicePathGuid);
1571 if (StrCmp (ValueStr, L"XonXoff") == 0) {
1572 UartFlowControl->FlowControlMap = 2;
1573 } else if (StrCmp (ValueStr, L"Hardware") == 0) {
1574 UartFlowControl->FlowControlMap = 1;
1575 } else {
1576 UartFlowControl->FlowControlMap = 0;
1577 }
1578
1579 return (EFI_DEVICE_PATH_PROTOCOL *) UartFlowControl;
1580}
1581
1582/**
1583 Converts a text device path node to Serial Attached SCSI device path structure.
1584
1585 @param TextDeviceNode The input Text device path node.
1586
1587 @return A pointer to the newly-created Serial Attached SCSI device path structure.
1588
1589**/
1590EFI_DEVICE_PATH_PROTOCOL *
1591DevPathFromTextSAS (
1592 IN CHAR16 *TextDeviceNode
1593 )
1594{
1595 CHAR16 *AddressStr;
1596 CHAR16 *LunStr;
1597 CHAR16 *RTPStr;
1598 CHAR16 *SASSATAStr;
1599 CHAR16 *LocationStr;
1600 CHAR16 *ConnectStr;
1601 CHAR16 *DriveBayStr;
1602 CHAR16 *ReservedStr;
1603 UINT16 Info;
1604 UINT16 Uint16;
1605 SAS_DEVICE_PATH *Sas;
1606
1607 AddressStr = GetNextParamStr (&TextDeviceNode);
1608 LunStr = GetNextParamStr (&TextDeviceNode);
1609 RTPStr = GetNextParamStr (&TextDeviceNode);
1610 SASSATAStr = GetNextParamStr (&TextDeviceNode);
1611 LocationStr = GetNextParamStr (&TextDeviceNode);
1612 ConnectStr = GetNextParamStr (&TextDeviceNode);
1613 DriveBayStr = GetNextParamStr (&TextDeviceNode);
1614 ReservedStr = GetNextParamStr (&TextDeviceNode);
1615 Sas = (SAS_DEVICE_PATH *) CreateDeviceNode (
1616 MESSAGING_DEVICE_PATH,
1617 MSG_VENDOR_DP,
1618 (UINT16) sizeof (SAS_DEVICE_PATH)
1619 );
1620
1621 CopyGuid (&Sas->Guid, &gEfiSasDevicePathGuid);
1622 Strtoi64 (AddressStr, &Sas->SasAddress);
1623 Strtoi64 (LunStr, &Sas->Lun);
1624 Sas->RelativeTargetPort = (UINT16) Strtoi (RTPStr);
1625
1626 if (StrCmp (SASSATAStr, L"NoTopology") == 0) {
1627 Info = 0x0;
1628
1629 } else if ((StrCmp (SASSATAStr, L"SATA") == 0) || (StrCmp (SASSATAStr, L"SAS") == 0)) {
1630
1631 Uint16 = (UINT16) Strtoi (DriveBayStr);
1632 if (Uint16 == 0) {
1633 Info = 0x1;
1634 } else {
1635 Info = (UINT16) (0x2 | ((Uint16 - 1) << 8));
1636 }
1637
1638 if (StrCmp (SASSATAStr, L"SATA") == 0) {
1639 Info |= BIT4;
1640 }
1641
1642 //
1643 // Location is an integer between 0 and 1 or else
1644 // the keyword Internal (0) or External (1).
1645 //
1646 if (StrCmp (LocationStr, L"External") == 0) {
1647 Uint16 = 1;
1648 } else if (StrCmp (LocationStr, L"Internal") == 0) {
1649 Uint16 = 0;
1650 } else {
1651 Uint16 = ((UINT16) Strtoi (LocationStr) & BIT0);
1652 }
1653 Info |= (Uint16 << 5);
1654
1655 //
1656 // Connect is an integer between 0 and 3 or else
1657 // the keyword Direct (0) or Expanded (1).
1658 //
1659 if (StrCmp (ConnectStr, L"Expanded") == 0) {
1660 Uint16 = 1;
1661 } else if (StrCmp (ConnectStr, L"Direct") == 0) {
1662 Uint16 = 0;
1663 } else {
1664 Uint16 = ((UINT16) Strtoi (ConnectStr) & (BIT0 | BIT1));
1665 }
1666 Info |= (Uint16 << 6);
1667
1668 } else {
1669 Info = (UINT16) Strtoi (SASSATAStr);
1670 }
1671
1672 Sas->DeviceTopology = Info;
1673 Sas->Reserved = (UINT32) Strtoi (ReservedStr);
1674
1675 return (EFI_DEVICE_PATH_PROTOCOL *) Sas;
1676}
1677
1678/**
1679 Converts a text device path node to Serial Attached SCSI Ex device path structure.
1680
1681 @param TextDeviceNode The input Text device path node.
1682
1683 @return A pointer to the newly-created Serial Attached SCSI Ex device path structure.
1684
1685**/
1686EFI_DEVICE_PATH_PROTOCOL *
1687DevPathFromTextSasEx (
1688 IN CHAR16 *TextDeviceNode
1689 )
1690{
1691 CHAR16 *AddressStr;
1692 CHAR16 *LunStr;
1693 CHAR16 *RTPStr;
1694 CHAR16 *SASSATAStr;
1695 CHAR16 *LocationStr;
1696 CHAR16 *ConnectStr;
1697 CHAR16 *DriveBayStr;
1698 UINT16 Info;
1699 UINT16 Uint16;
1700 UINT64 SasAddress;
1701 UINT64 Lun;
1702 SASEX_DEVICE_PATH *SasEx;
1703
1704 AddressStr = GetNextParamStr (&TextDeviceNode);
1705 LunStr = GetNextParamStr (&TextDeviceNode);
1706 RTPStr = GetNextParamStr (&TextDeviceNode);
1707 SASSATAStr = GetNextParamStr (&TextDeviceNode);
1708 LocationStr = GetNextParamStr (&TextDeviceNode);
1709 ConnectStr = GetNextParamStr (&TextDeviceNode);
1710 DriveBayStr = GetNextParamStr (&TextDeviceNode);
1711 SasEx = (SASEX_DEVICE_PATH *) CreateDeviceNode (
1712 MESSAGING_DEVICE_PATH,
1713 MSG_SASEX_DP,
1714 (UINT16) sizeof (SASEX_DEVICE_PATH)
1715 );
1716
1717 Strtoi64 (AddressStr, &SasAddress);
1718 Strtoi64 (LunStr, &Lun);
1719 WriteUnaligned64 ((UINT64 *) &SasEx->SasAddress, SwapBytes64 (SasAddress));
1720 WriteUnaligned64 ((UINT64 *) &SasEx->Lun, SwapBytes64 (Lun));
1721 SasEx->RelativeTargetPort = (UINT16) Strtoi (RTPStr);
1722
1723 if (StrCmp (SASSATAStr, L"NoTopology") == 0) {
1724 Info = 0x0;
1725
1726 } else if ((StrCmp (SASSATAStr, L"SATA") == 0) || (StrCmp (SASSATAStr, L"SAS") == 0)) {
1727
1728 Uint16 = (UINT16) Strtoi (DriveBayStr);
1729 if (Uint16 == 0) {
1730 Info = 0x1;
1731 } else {
1732 Info = (UINT16) (0x2 | ((Uint16 - 1) << 8));
1733 }
1734
1735 if (StrCmp (SASSATAStr, L"SATA") == 0) {
1736 Info |= BIT4;
1737 }
1738
1739 //
1740 // Location is an integer between 0 and 1 or else
1741 // the keyword Internal (0) or External (1).
1742 //
1743 if (StrCmp (LocationStr, L"External") == 0) {
1744 Uint16 = 1;
1745 } else if (StrCmp (LocationStr, L"Internal") == 0) {
1746 Uint16 = 0;
1747 } else {
1748 Uint16 = ((UINT16) Strtoi (LocationStr) & BIT0);
1749 }
1750 Info |= (Uint16 << 5);
1751
1752 //
1753 // Connect is an integer between 0 and 3 or else
1754 // the keyword Direct (0) or Expanded (1).
1755 //
1756 if (StrCmp (ConnectStr, L"Expanded") == 0) {
1757 Uint16 = 1;
1758 } else if (StrCmp (ConnectStr, L"Direct") == 0) {
1759 Uint16 = 0;
1760 } else {
1761 Uint16 = ((UINT16) Strtoi (ConnectStr) & (BIT0 | BIT1));
1762 }
1763 Info |= (Uint16 << 6);
1764
1765 } else {
1766 Info = (UINT16) Strtoi (SASSATAStr);
1767 }
1768
1769 SasEx->DeviceTopology = Info;
1770
1771 return (EFI_DEVICE_PATH_PROTOCOL *) SasEx;
1772}
1773
1774/**
1775 Converts a text device path node to NVM Express Namespace device path structure.
1776
1777 @param TextDeviceNode The input Text device path node.
1778
1779 @return A pointer to the newly-created NVM Express Namespace device path structure.
1780
1781**/
1782EFI_DEVICE_PATH_PROTOCOL *
1783DevPathFromTextNVMe (
1784 IN CHAR16 *TextDeviceNode
1785 )
1786{
1787 CHAR16 *NamespaceIdStr;
1788 CHAR16 *NamespaceUuidStr;
1789 NVME_NAMESPACE_DEVICE_PATH *Nvme;
1790 UINT8 *Uuid;
1791 UINTN Index;
1792
1793 NamespaceIdStr = GetNextParamStr (&TextDeviceNode);
1794 NamespaceUuidStr = GetNextParamStr (&TextDeviceNode);
1795 Nvme = (NVME_NAMESPACE_DEVICE_PATH *) CreateDeviceNode (
1796 MESSAGING_DEVICE_PATH,
1797 MSG_NVME_NAMESPACE_DP,
1798 (UINT16) sizeof (NVME_NAMESPACE_DEVICE_PATH)
1799 );
1800
1801 Nvme->NamespaceId = (UINT32) Strtoi (NamespaceIdStr);
1802 Uuid = (UINT8 *) &Nvme->NamespaceUuid;
1803
1804 Index = sizeof (Nvme->NamespaceUuid) / sizeof (UINT8);
1805 while (Index-- != 0) {
1806 Uuid[Index] = (UINT8) StrHexToUintn (SplitStr (&NamespaceUuidStr, L'-'));
1807 }
1808
1809 return (EFI_DEVICE_PATH_PROTOCOL *) Nvme;
1810}
1811
1812/**
1813 Converts a text device path node to UFS device path structure.
1814
1815 @param TextDeviceNode The input Text device path node.
1816
1817 @return A pointer to the newly-created UFS device path structure.
1818
1819**/
1820EFI_DEVICE_PATH_PROTOCOL *
1821DevPathFromTextUfs (
1822 IN CHAR16 *TextDeviceNode
1823 )
1824{
1825 CHAR16 *PunStr;
1826 CHAR16 *LunStr;
1827 UFS_DEVICE_PATH *Ufs;
1828
1829 PunStr = GetNextParamStr (&TextDeviceNode);
1830 LunStr = GetNextParamStr (&TextDeviceNode);
1831 Ufs = (UFS_DEVICE_PATH *) CreateDeviceNode (
1832 MESSAGING_DEVICE_PATH,
1833 MSG_UFS_DP,
1834 (UINT16) sizeof (UFS_DEVICE_PATH)
1835 );
1836
1837 Ufs->Pun = (UINT8) Strtoi (PunStr);
1838 Ufs->Lun = (UINT8) Strtoi (LunStr);
1839
1840 return (EFI_DEVICE_PATH_PROTOCOL *) Ufs;
1841}
1842
1843/**
1844 Converts a text device path node to Debug Port device path structure.
1845
1846 @param TextDeviceNode The input Text device path node.
1847
1848 @return A pointer to the newly-created Debug Port device path structure.
1849
1850**/
1851EFI_DEVICE_PATH_PROTOCOL *
1852DevPathFromTextDebugPort (
1853 IN CHAR16 *TextDeviceNode
1854 )
1855{
1856 VENDOR_DEFINED_MESSAGING_DEVICE_PATH *Vend;
1857
1858 Vend = (VENDOR_DEFINED_MESSAGING_DEVICE_PATH *) CreateDeviceNode (
1859 MESSAGING_DEVICE_PATH,
1860 MSG_VENDOR_DP,
1861 (UINT16) sizeof (VENDOR_DEFINED_MESSAGING_DEVICE_PATH)
1862 );
1863
1864 CopyGuid (&Vend->Guid, &gEfiDebugPortProtocolGuid);
1865
1866 return (EFI_DEVICE_PATH_PROTOCOL *) Vend;
1867}
1868
1869/**
1870 Converts a text device path node to MAC device path structure.
1871
1872 @param TextDeviceNode The input Text device path node.
1873
1874 @return A pointer to the newly-created MAC device path structure.
1875
1876**/
1877EFI_DEVICE_PATH_PROTOCOL *
1878DevPathFromTextMAC (
1879 IN CHAR16 *TextDeviceNode
1880 )
1881{
1882 CHAR16 *AddressStr;
1883 CHAR16 *IfTypeStr;
1884 UINTN Length;
1885 MAC_ADDR_DEVICE_PATH *MACDevPath;
1886
1887 AddressStr = GetNextParamStr (&TextDeviceNode);
1888 IfTypeStr = GetNextParamStr (&TextDeviceNode);
1889 MACDevPath = (MAC_ADDR_DEVICE_PATH *) CreateDeviceNode (
1890 MESSAGING_DEVICE_PATH,
1891 MSG_MAC_ADDR_DP,
1892 (UINT16) sizeof (MAC_ADDR_DEVICE_PATH)
1893 );
1894
1895 MACDevPath->IfType = (UINT8) Strtoi (IfTypeStr);
1896
1897 Length = sizeof (EFI_MAC_ADDRESS);
1898 StrToBuf (&MACDevPath->MacAddress.Addr[0], Length, AddressStr);
1899
1900 return (EFI_DEVICE_PATH_PROTOCOL *) MACDevPath;
1901}
1902
1903
1904/**
1905 Converts a text format to the network protocol ID.
1906
1907 @param Text String of protocol field.
1908
1909 @return Network protocol ID .
1910
1911**/
1912UINTN
1913NetworkProtocolFromText (
1914 IN CHAR16 *Text
1915 )
1916{
1917 if (StrCmp (Text, L"UDP") == 0) {
1918 return RFC_1700_UDP_PROTOCOL;
1919 }
1920
1921 if (StrCmp (Text, L"TCP") == 0) {
1922 return RFC_1700_TCP_PROTOCOL;
1923 }
1924
1925 return Strtoi (Text);
1926}
1927
1928
1929/**
1930 Converts a text device path node to IPV4 device path structure.
1931
1932 @param TextDeviceNode The input Text device path node.
1933
1934 @return A pointer to the newly-created IPV4 device path structure.
1935
1936**/
1937EFI_DEVICE_PATH_PROTOCOL *
1938DevPathFromTextIPv4 (
1939 IN CHAR16 *TextDeviceNode
1940 )
1941{
1942 CHAR16 *RemoteIPStr;
1943 CHAR16 *ProtocolStr;
1944 CHAR16 *TypeStr;
1945 CHAR16 *LocalIPStr;
1946 CHAR16 *GatewayIPStr;
1947 CHAR16 *SubnetMaskStr;
1948 IPv4_DEVICE_PATH *IPv4;
1949
1950 RemoteIPStr = GetNextParamStr (&TextDeviceNode);
1951 ProtocolStr = GetNextParamStr (&TextDeviceNode);
1952 TypeStr = GetNextParamStr (&TextDeviceNode);
1953 LocalIPStr = GetNextParamStr (&TextDeviceNode);
1954 GatewayIPStr = GetNextParamStr (&TextDeviceNode);
1955 SubnetMaskStr = GetNextParamStr (&TextDeviceNode);
1956 IPv4 = (IPv4_DEVICE_PATH *) CreateDeviceNode (
1957 MESSAGING_DEVICE_PATH,
1958 MSG_IPv4_DP,
1959 (UINT16) sizeof (IPv4_DEVICE_PATH)
1960 );
1961
1962 StrToIPv4Addr (&RemoteIPStr, &IPv4->RemoteIpAddress);
1963 IPv4->Protocol = (UINT16) NetworkProtocolFromText (ProtocolStr);
1964 if (StrCmp (TypeStr, L"Static") == 0) {
1965 IPv4->StaticIpAddress = TRUE;
1966 } else {
1967 IPv4->StaticIpAddress = FALSE;
1968 }
1969
1970 StrToIPv4Addr (&LocalIPStr, &IPv4->LocalIpAddress);
1971 if (!IS_NULL (*GatewayIPStr) && !IS_NULL (*SubnetMaskStr)) {
1972 StrToIPv4Addr (&GatewayIPStr, &IPv4->GatewayIpAddress);
1973 StrToIPv4Addr (&SubnetMaskStr, &IPv4->SubnetMask);
1974 } else {
1975 ZeroMem (&IPv4->GatewayIpAddress, sizeof (IPv4->GatewayIpAddress));
1976 ZeroMem (&IPv4->SubnetMask, sizeof (IPv4->SubnetMask));
1977 }
1978
1979 IPv4->LocalPort = 0;
1980 IPv4->RemotePort = 0;
1981
1982 return (EFI_DEVICE_PATH_PROTOCOL *) IPv4;
1983}
1984
1985/**
1986 Converts a text device path node to IPV6 device path structure.
1987
1988 @param TextDeviceNode The input Text device path node.
1989
1990 @return A pointer to the newly-created IPV6 device path structure.
1991
1992**/
1993EFI_DEVICE_PATH_PROTOCOL *
1994DevPathFromTextIPv6 (
1995 IN CHAR16 *TextDeviceNode
1996 )
1997{
1998 CHAR16 *RemoteIPStr;
1999 CHAR16 *ProtocolStr;
2000 CHAR16 *TypeStr;
2001 CHAR16 *LocalIPStr;
2002 CHAR16 *GatewayIPStr;
2003 CHAR16 *PrefixLengthStr;
2004 IPv6_DEVICE_PATH *IPv6;
2005
2006 RemoteIPStr = GetNextParamStr (&TextDeviceNode);
2007 ProtocolStr = GetNextParamStr (&TextDeviceNode);
2008 TypeStr = GetNextParamStr (&TextDeviceNode);
2009 LocalIPStr = GetNextParamStr (&TextDeviceNode);
2010 PrefixLengthStr = GetNextParamStr (&TextDeviceNode);
2011 GatewayIPStr = GetNextParamStr (&TextDeviceNode);
2012 IPv6 = (IPv6_DEVICE_PATH *) CreateDeviceNode (
2013 MESSAGING_DEVICE_PATH,
2014 MSG_IPv6_DP,
2015 (UINT16) sizeof (IPv6_DEVICE_PATH)
2016 );
2017
2018 StrToIPv6Addr (&RemoteIPStr, &IPv6->RemoteIpAddress);
2019 IPv6->Protocol = (UINT16) NetworkProtocolFromText (ProtocolStr);
2020 if (StrCmp (TypeStr, L"Static") == 0) {
2021 IPv6->IpAddressOrigin = 0;
2022 } else if (StrCmp (TypeStr, L"StatelessAutoConfigure") == 0) {
2023 IPv6->IpAddressOrigin = 1;
2024 } else {
2025 IPv6->IpAddressOrigin = 2;
2026 }
2027
2028 StrToIPv6Addr (&LocalIPStr, &IPv6->LocalIpAddress);
2029 if (!IS_NULL (*GatewayIPStr) && !IS_NULL (*PrefixLengthStr)) {
2030 StrToIPv6Addr (&GatewayIPStr, &IPv6->GatewayIpAddress);
2031 IPv6->PrefixLength = (UINT8) Strtoi (PrefixLengthStr);
2032 } else {
2033 ZeroMem (&IPv6->GatewayIpAddress, sizeof (IPv6->GatewayIpAddress));
2034 IPv6->PrefixLength = 0;
2035 }
2036
2037 IPv6->LocalPort = 0;
2038 IPv6->RemotePort = 0;
2039
2040 return (EFI_DEVICE_PATH_PROTOCOL *) IPv6;
2041}
2042
2043/**
2044 Converts a text device path node to UART device path structure.
2045
2046 @param TextDeviceNode The input Text device path node.
2047
2048 @return A pointer to the newly-created UART device path structure.
2049
2050**/
2051EFI_DEVICE_PATH_PROTOCOL *
2052DevPathFromTextUart (
2053 IN CHAR16 *TextDeviceNode
2054 )
2055{
2056 CHAR16 *BaudStr;
2057 CHAR16 *DataBitsStr;
2058 CHAR16 *ParityStr;
2059 CHAR16 *StopBitsStr;
2060 UART_DEVICE_PATH *Uart;
2061
2062 BaudStr = GetNextParamStr (&TextDeviceNode);
2063 DataBitsStr = GetNextParamStr (&TextDeviceNode);
2064 ParityStr = GetNextParamStr (&TextDeviceNode);
2065 StopBitsStr = GetNextParamStr (&TextDeviceNode);
2066 Uart = (UART_DEVICE_PATH *) CreateDeviceNode (
2067 MESSAGING_DEVICE_PATH,
2068 MSG_UART_DP,
2069 (UINT16) sizeof (UART_DEVICE_PATH)
2070 );
2071
2072 if (StrCmp (BaudStr, L"DEFAULT") == 0) {
2073 Uart->BaudRate = 115200;
2074 } else {
2075 Strtoi64 (BaudStr, &Uart->BaudRate);
2076 }
2077 Uart->DataBits = (UINT8) ((StrCmp (DataBitsStr, L"DEFAULT") == 0) ? 8 : Strtoi (DataBitsStr));
2078 switch (*ParityStr) {
2079 case L'D':
2080 Uart->Parity = 0;
2081 break;
2082
2083 case L'N':
2084 Uart->Parity = 1;
2085 break;
2086
2087 case L'E':
2088 Uart->Parity = 2;
2089 break;
2090
2091 case L'O':
2092 Uart->Parity = 3;
2093 break;
2094
2095 case L'M':
2096 Uart->Parity = 4;
2097 break;
2098
2099 case L'S':
2100 Uart->Parity = 5;
2101 break;
2102
2103 default:
2104 Uart->Parity = (UINT8) Strtoi (ParityStr);
2105 break;
2106 }
2107
2108 if (StrCmp (StopBitsStr, L"D") == 0) {
2109 Uart->StopBits = (UINT8) 0;
2110 } else if (StrCmp (StopBitsStr, L"1") == 0) {
2111 Uart->StopBits = (UINT8) 1;
2112 } else if (StrCmp (StopBitsStr, L"1.5") == 0) {
2113 Uart->StopBits = (UINT8) 2;
2114 } else if (StrCmp (StopBitsStr, L"2") == 0) {
2115 Uart->StopBits = (UINT8) 3;
2116 } else {
2117 Uart->StopBits = (UINT8) Strtoi (StopBitsStr);
2118 }
2119
2120 return (EFI_DEVICE_PATH_PROTOCOL *) Uart;
2121}
2122
2123/**
2124 Converts a text device path node to USB class device path structure.
2125
2126 @param TextDeviceNode The input Text device path node.
2127 @param UsbClassText A pointer to USB_CLASS_TEXT structure to be integrated to USB Class Text.
2128
2129 @return A pointer to the newly-created USB class device path structure.
2130
2131**/
2132EFI_DEVICE_PATH_PROTOCOL *
2133ConvertFromTextUsbClass (
2134 IN CHAR16 *TextDeviceNode,
2135 IN USB_CLASS_TEXT *UsbClassText
2136 )
2137{
2138 CHAR16 *VIDStr;
2139 CHAR16 *PIDStr;
2140 CHAR16 *ClassStr;
2141 CHAR16 *SubClassStr;
2142 CHAR16 *ProtocolStr;
2143 USB_CLASS_DEVICE_PATH *UsbClass;
2144
2145 UsbClass = (USB_CLASS_DEVICE_PATH *) CreateDeviceNode (
2146 MESSAGING_DEVICE_PATH,
2147 MSG_USB_CLASS_DP,
2148 (UINT16) sizeof (USB_CLASS_DEVICE_PATH)
2149 );
2150
2151 VIDStr = GetNextParamStr (&TextDeviceNode);
2152 PIDStr = GetNextParamStr (&TextDeviceNode);
2153 if (UsbClassText->ClassExist) {
2154 ClassStr = GetNextParamStr (&TextDeviceNode);
2155 UsbClass->DeviceClass = (UINT8) Strtoi (ClassStr);
2156 } else {
2157 UsbClass->DeviceClass = UsbClassText->Class;
2158 }
2159 if (UsbClassText->SubClassExist) {
2160 SubClassStr = GetNextParamStr (&TextDeviceNode);
2161 UsbClass->DeviceSubClass = (UINT8) Strtoi (SubClassStr);
2162 } else {
2163 UsbClass->DeviceSubClass = UsbClassText->SubClass;
2164 }
2165
2166 ProtocolStr = GetNextParamStr (&TextDeviceNode);
2167
2168 UsbClass->VendorId = (UINT16) Strtoi (VIDStr);
2169 UsbClass->ProductId = (UINT16) Strtoi (PIDStr);
2170 UsbClass->DeviceProtocol = (UINT8) Strtoi (ProtocolStr);
2171
2172 return (EFI_DEVICE_PATH_PROTOCOL *) UsbClass;
2173}
2174
2175
2176/**
2177 Converts a text device path node to USB class device path structure.
2178
2179 @param TextDeviceNode The input Text device path node.
2180
2181 @return A pointer to the newly-created USB class device path structure.
2182
2183**/
2184EFI_DEVICE_PATH_PROTOCOL *
2185DevPathFromTextUsbClass (
2186 IN CHAR16 *TextDeviceNode
2187 )
2188{
2189 USB_CLASS_TEXT UsbClassText;
2190
2191 UsbClassText.ClassExist = TRUE;
2192 UsbClassText.SubClassExist = TRUE;
2193
2194 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2195}
2196
2197/**
2198 Converts a text device path node to USB audio device path structure.
2199
2200 @param TextDeviceNode The input Text device path node.
2201
2202 @return A pointer to the newly-created USB audio device path structure.
2203
2204**/
2205EFI_DEVICE_PATH_PROTOCOL *
2206DevPathFromTextUsbAudio (
2207 IN CHAR16 *TextDeviceNode
2208 )
2209{
2210 USB_CLASS_TEXT UsbClassText;
2211
2212 UsbClassText.ClassExist = FALSE;
2213 UsbClassText.Class = USB_CLASS_AUDIO;
2214 UsbClassText.SubClassExist = TRUE;
2215
2216 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2217}
2218
2219/**
2220 Converts a text device path node to USB CDC Control device path structure.
2221
2222 @param TextDeviceNode The input Text device path node.
2223
2224 @return A pointer to the newly-created USB CDC Control device path structure.
2225
2226**/
2227EFI_DEVICE_PATH_PROTOCOL *
2228DevPathFromTextUsbCDCControl (
2229 IN CHAR16 *TextDeviceNode
2230 )
2231{
2232 USB_CLASS_TEXT UsbClassText;
2233
2234 UsbClassText.ClassExist = FALSE;
2235 UsbClassText.Class = USB_CLASS_CDCCONTROL;
2236 UsbClassText.SubClassExist = TRUE;
2237
2238 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2239}
2240
2241/**
2242 Converts a text device path node to USB HID device path structure.
2243
2244 @param TextDeviceNode The input Text device path node.
2245
2246 @return A pointer to the newly-created USB HID device path structure.
2247
2248**/
2249EFI_DEVICE_PATH_PROTOCOL *
2250DevPathFromTextUsbHID (
2251 IN CHAR16 *TextDeviceNode
2252 )
2253{
2254 USB_CLASS_TEXT UsbClassText;
2255
2256 UsbClassText.ClassExist = FALSE;
2257 UsbClassText.Class = USB_CLASS_HID;
2258 UsbClassText.SubClassExist = TRUE;
2259
2260 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2261}
2262
2263/**
2264 Converts a text device path node to USB Image device path structure.
2265
2266 @param TextDeviceNode The input Text device path node.
2267
2268 @return A pointer to the newly-created USB Image device path structure.
2269
2270**/
2271EFI_DEVICE_PATH_PROTOCOL *
2272DevPathFromTextUsbImage (
2273 IN CHAR16 *TextDeviceNode
2274 )
2275{
2276 USB_CLASS_TEXT UsbClassText;
2277
2278 UsbClassText.ClassExist = FALSE;
2279 UsbClassText.Class = USB_CLASS_IMAGE;
2280 UsbClassText.SubClassExist = TRUE;
2281
2282 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2283}
2284
2285/**
2286 Converts a text device path node to USB Print device path structure.
2287
2288 @param TextDeviceNode The input Text device path node.
2289
2290 @return A pointer to the newly-created USB Print device path structure.
2291
2292**/
2293EFI_DEVICE_PATH_PROTOCOL *
2294DevPathFromTextUsbPrinter (
2295 IN CHAR16 *TextDeviceNode
2296 )
2297{
2298 USB_CLASS_TEXT UsbClassText;
2299
2300 UsbClassText.ClassExist = FALSE;
2301 UsbClassText.Class = USB_CLASS_PRINTER;
2302 UsbClassText.SubClassExist = TRUE;
2303
2304 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2305}
2306
2307/**
2308 Converts a text device path node to USB mass storage device path structure.
2309
2310 @param TextDeviceNode The input Text device path node.
2311
2312 @return A pointer to the newly-created USB mass storage device path structure.
2313
2314**/
2315EFI_DEVICE_PATH_PROTOCOL *
2316DevPathFromTextUsbMassStorage (
2317 IN CHAR16 *TextDeviceNode
2318 )
2319{
2320 USB_CLASS_TEXT UsbClassText;
2321
2322 UsbClassText.ClassExist = FALSE;
2323 UsbClassText.Class = USB_CLASS_MASS_STORAGE;
2324 UsbClassText.SubClassExist = TRUE;
2325
2326 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2327}
2328
2329/**
2330 Converts a text device path node to USB HUB device path structure.
2331
2332 @param TextDeviceNode The input Text device path node.
2333
2334 @return A pointer to the newly-created USB HUB device path structure.
2335
2336**/
2337EFI_DEVICE_PATH_PROTOCOL *
2338DevPathFromTextUsbHub (
2339 IN CHAR16 *TextDeviceNode
2340 )
2341{
2342 USB_CLASS_TEXT UsbClassText;
2343
2344 UsbClassText.ClassExist = FALSE;
2345 UsbClassText.Class = USB_CLASS_HUB;
2346 UsbClassText.SubClassExist = TRUE;
2347
2348 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2349}
2350
2351/**
2352 Converts a text device path node to USB CDC data device path structure.
2353
2354 @param TextDeviceNode The input Text device path node.
2355
2356 @return A pointer to the newly-created USB CDC data device path structure.
2357
2358**/
2359EFI_DEVICE_PATH_PROTOCOL *
2360DevPathFromTextUsbCDCData (
2361 IN CHAR16 *TextDeviceNode
2362 )
2363{
2364 USB_CLASS_TEXT UsbClassText;
2365
2366 UsbClassText.ClassExist = FALSE;
2367 UsbClassText.Class = USB_CLASS_CDCDATA;
2368 UsbClassText.SubClassExist = TRUE;
2369
2370 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2371}
2372
2373/**
2374 Converts a text device path node to USB smart card device path structure.
2375
2376 @param TextDeviceNode The input Text device path node.
2377
2378 @return A pointer to the newly-created USB smart card device path structure.
2379
2380**/
2381EFI_DEVICE_PATH_PROTOCOL *
2382DevPathFromTextUsbSmartCard (
2383 IN CHAR16 *TextDeviceNode
2384 )
2385{
2386 USB_CLASS_TEXT UsbClassText;
2387
2388 UsbClassText.ClassExist = FALSE;
2389 UsbClassText.Class = USB_CLASS_SMART_CARD;
2390 UsbClassText.SubClassExist = TRUE;
2391
2392 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2393}
2394
2395/**
2396 Converts a text device path node to USB video device path structure.
2397
2398 @param TextDeviceNode The input Text device path node.
2399
2400 @return A pointer to the newly-created USB video device path structure.
2401
2402**/
2403EFI_DEVICE_PATH_PROTOCOL *
2404DevPathFromTextUsbVideo (
2405 IN CHAR16 *TextDeviceNode
2406 )
2407{
2408 USB_CLASS_TEXT UsbClassText;
2409
2410 UsbClassText.ClassExist = FALSE;
2411 UsbClassText.Class = USB_CLASS_VIDEO;
2412 UsbClassText.SubClassExist = TRUE;
2413
2414 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2415}
2416
2417/**
2418 Converts a text device path node to USB diagnostic device path structure.
2419
2420 @param TextDeviceNode The input Text device path node.
2421
2422 @return A pointer to the newly-created USB diagnostic device path structure.
2423
2424**/
2425EFI_DEVICE_PATH_PROTOCOL *
2426DevPathFromTextUsbDiagnostic (
2427 IN CHAR16 *TextDeviceNode
2428 )
2429{
2430 USB_CLASS_TEXT UsbClassText;
2431
2432 UsbClassText.ClassExist = FALSE;
2433 UsbClassText.Class = USB_CLASS_DIAGNOSTIC;
2434 UsbClassText.SubClassExist = TRUE;
2435
2436 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2437}
2438
2439/**
2440 Converts a text device path node to USB wireless device path structure.
2441
2442 @param TextDeviceNode The input Text device path node.
2443
2444 @return A pointer to the newly-created USB wireless device path structure.
2445
2446**/
2447EFI_DEVICE_PATH_PROTOCOL *
2448DevPathFromTextUsbWireless (
2449 IN CHAR16 *TextDeviceNode
2450 )
2451{
2452 USB_CLASS_TEXT UsbClassText;
2453
2454 UsbClassText.ClassExist = FALSE;
2455 UsbClassText.Class = USB_CLASS_WIRELESS;
2456 UsbClassText.SubClassExist = TRUE;
2457
2458 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2459}
2460
2461/**
2462 Converts a text device path node to USB device firmware update device path structure.
2463
2464 @param TextDeviceNode The input Text device path node.
2465
2466 @return A pointer to the newly-created USB device firmware update device path structure.
2467
2468**/
2469EFI_DEVICE_PATH_PROTOCOL *
2470DevPathFromTextUsbDeviceFirmwareUpdate (
2471 IN CHAR16 *TextDeviceNode
2472 )
2473{
2474 USB_CLASS_TEXT UsbClassText;
2475
2476 UsbClassText.ClassExist = FALSE;
2477 UsbClassText.Class = USB_CLASS_RESERVE;
2478 UsbClassText.SubClassExist = FALSE;
2479 UsbClassText.SubClass = USB_SUBCLASS_FW_UPDATE;
2480
2481 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2482}
2483
2484/**
2485 Converts a text device path node to USB IRDA bridge device path structure.
2486
2487 @param TextDeviceNode The input Text device path node.
2488
2489 @return A pointer to the newly-created USB IRDA bridge device path structure.
2490
2491**/
2492EFI_DEVICE_PATH_PROTOCOL *
2493DevPathFromTextUsbIrdaBridge (
2494 IN CHAR16 *TextDeviceNode
2495 )
2496{
2497 USB_CLASS_TEXT UsbClassText;
2498
2499 UsbClassText.ClassExist = FALSE;
2500 UsbClassText.Class = USB_CLASS_RESERVE;
2501 UsbClassText.SubClassExist = FALSE;
2502 UsbClassText.SubClass = USB_SUBCLASS_IRDA_BRIDGE;
2503
2504 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2505}
2506
2507/**
2508 Converts a text device path node to USB text and measurement device path structure.
2509
2510 @param TextDeviceNode The input Text device path node.
2511
2512 @return A pointer to the newly-created USB text and measurement device path structure.
2513
2514**/
2515EFI_DEVICE_PATH_PROTOCOL *
2516DevPathFromTextUsbTestAndMeasurement (
2517 IN CHAR16 *TextDeviceNode
2518 )
2519{
2520 USB_CLASS_TEXT UsbClassText;
2521
2522 UsbClassText.ClassExist = FALSE;
2523 UsbClassText.Class = USB_CLASS_RESERVE;
2524 UsbClassText.SubClassExist = FALSE;
2525 UsbClassText.SubClass = USB_SUBCLASS_TEST;
2526
2527 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2528}
2529
2530/**
2531 Converts a text device path node to USB WWID device path structure.
2532
2533 @param TextDeviceNode The input Text device path node.
2534
2535 @return A pointer to the newly-created USB WWID device path structure.
2536
2537**/
2538EFI_DEVICE_PATH_PROTOCOL *
2539DevPathFromTextUsbWwid (
2540 IN CHAR16 *TextDeviceNode
2541 )
2542{
2543 CHAR16 *VIDStr;
2544 CHAR16 *PIDStr;
2545 CHAR16 *InterfaceNumStr;
2546 CHAR16 *SerialNumberStr;
2547 USB_WWID_DEVICE_PATH *UsbWwid;
2548 UINTN SerialNumberStrLen;
2549
2550 VIDStr = GetNextParamStr (&TextDeviceNode);
2551 PIDStr = GetNextParamStr (&TextDeviceNode);
2552 InterfaceNumStr = GetNextParamStr (&TextDeviceNode);
2553 SerialNumberStr = GetNextParamStr (&TextDeviceNode);
2554 SerialNumberStrLen = StrLen (SerialNumberStr);
2555 if (SerialNumberStrLen >= 2 &&
2556 SerialNumberStr[0] == L'\"' &&
2557 SerialNumberStr[SerialNumberStrLen - 1] == L'\"'
2558 ) {
2559 SerialNumberStr[SerialNumberStrLen - 1] = L'\0';
2560 SerialNumberStr++;
2561 SerialNumberStrLen -= 2;
2562 }
2563 UsbWwid = (USB_WWID_DEVICE_PATH *) CreateDeviceNode (
2564 MESSAGING_DEVICE_PATH,
2565 MSG_USB_WWID_DP,
2566 (UINT16) (sizeof (USB_WWID_DEVICE_PATH) + SerialNumberStrLen * sizeof (CHAR16))
2567 );
2568 UsbWwid->VendorId = (UINT16) Strtoi (VIDStr);
2569 UsbWwid->ProductId = (UINT16) Strtoi (PIDStr);
2570 UsbWwid->InterfaceNumber = (UINT16) Strtoi (InterfaceNumStr);
2571 StrnCpy ((CHAR16 *) ((UINT8 *) UsbWwid + sizeof (USB_WWID_DEVICE_PATH)), SerialNumberStr, SerialNumberStrLen);
2572
2573 return (EFI_DEVICE_PATH_PROTOCOL *) UsbWwid;
2574}
2575
2576/**
2577 Converts a text device path node to Logic Unit device path structure.
2578
2579 @param TextDeviceNode The input Text device path node.
2580
2581 @return A pointer to the newly-created Logic Unit device path structure.
2582
2583**/
2584EFI_DEVICE_PATH_PROTOCOL *
2585DevPathFromTextUnit (
2586 IN CHAR16 *TextDeviceNode
2587 )
2588{
2589 CHAR16 *LunStr;
2590 DEVICE_LOGICAL_UNIT_DEVICE_PATH *LogicalUnit;
2591
2592 LunStr = GetNextParamStr (&TextDeviceNode);
2593 LogicalUnit = (DEVICE_LOGICAL_UNIT_DEVICE_PATH *) CreateDeviceNode (
2594 MESSAGING_DEVICE_PATH,
2595 MSG_DEVICE_LOGICAL_UNIT_DP,
2596 (UINT16) sizeof (DEVICE_LOGICAL_UNIT_DEVICE_PATH)
2597 );
2598
2599 LogicalUnit->Lun = (UINT8) Strtoi (LunStr);
2600
2601 return (EFI_DEVICE_PATH_PROTOCOL *) LogicalUnit;
2602}
2603
2604/**
2605 Converts a text device path node to iSCSI device path structure.
2606
2607 @param TextDeviceNode The input Text device path node.
2608
2609 @return A pointer to the newly-created iSCSI device path structure.
2610
2611**/
2612EFI_DEVICE_PATH_PROTOCOL *
2613DevPathFromTextiSCSI (
2614 IN CHAR16 *TextDeviceNode
2615 )
2616{
2617 UINT16 Options;
2618 CHAR16 *NameStr;
2619 CHAR16 *PortalGroupStr;
2620 CHAR16 *LunStr;
2621 CHAR16 *HeaderDigestStr;
2622 CHAR16 *DataDigestStr;
2623 CHAR16 *AuthenticationStr;
2624 CHAR16 *ProtocolStr;
2625 CHAR8 *AsciiStr;
2626 ISCSI_DEVICE_PATH_WITH_NAME *ISCSIDevPath;
2627
2628 NameStr = GetNextParamStr (&TextDeviceNode);
2629 PortalGroupStr = GetNextParamStr (&TextDeviceNode);
2630 LunStr = GetNextParamStr (&TextDeviceNode);
2631 HeaderDigestStr = GetNextParamStr (&TextDeviceNode);
2632 DataDigestStr = GetNextParamStr (&TextDeviceNode);
2633 AuthenticationStr = GetNextParamStr (&TextDeviceNode);
2634 ProtocolStr = GetNextParamStr (&TextDeviceNode);
2635 ISCSIDevPath = (ISCSI_DEVICE_PATH_WITH_NAME *) CreateDeviceNode (
2636 MESSAGING_DEVICE_PATH,
2637 MSG_ISCSI_DP,
2638 (UINT16) (sizeof (ISCSI_DEVICE_PATH_WITH_NAME) + StrLen (NameStr))
2639 );
2640
2641 AsciiStr = ISCSIDevPath->TargetName;
2642 StrToAscii (NameStr, &AsciiStr);
2643
2644 ISCSIDevPath->TargetPortalGroupTag = (UINT16) Strtoi (PortalGroupStr);
2645 Strtoi64 (LunStr, &ISCSIDevPath->Lun);
2646
2647 Options = 0x0000;
2648 if (StrCmp (HeaderDigestStr, L"CRC32C") == 0) {
2649 Options |= 0x0002;
2650 }
2651
2652 if (StrCmp (DataDigestStr, L"CRC32C") == 0) {
2653 Options |= 0x0008;
2654 }
2655
2656 if (StrCmp (AuthenticationStr, L"None") == 0) {
2657 Options |= 0x0800;
2658 }
2659
2660 if (StrCmp (AuthenticationStr, L"CHAP_UNI") == 0) {
2661 Options |= 0x1000;
2662 }
2663
2664 ISCSIDevPath->LoginOption = (UINT16) Options;
2665
2666 ISCSIDevPath->NetworkProtocol = (UINT16) StrCmp (ProtocolStr, L"TCP");
2667
2668 return (EFI_DEVICE_PATH_PROTOCOL *) ISCSIDevPath;
2669}
2670
2671/**
2672 Converts a text device path node to VLAN device path structure.
2673
2674 @param TextDeviceNode The input Text device path node.
2675
2676 @return A pointer to the newly-created VLAN device path structure.
2677
2678**/
2679EFI_DEVICE_PATH_PROTOCOL *
2680DevPathFromTextVlan (
2681 IN CHAR16 *TextDeviceNode
2682 )
2683{
2684 CHAR16 *VlanStr;
2685 VLAN_DEVICE_PATH *Vlan;
2686
2687 VlanStr = GetNextParamStr (&TextDeviceNode);
2688 Vlan = (VLAN_DEVICE_PATH *) CreateDeviceNode (
2689 MESSAGING_DEVICE_PATH,
2690 MSG_VLAN_DP,
2691 (UINT16) sizeof (VLAN_DEVICE_PATH)
2692 );
2693
2694 Vlan->VlanId = (UINT16) Strtoi (VlanStr);
2695
2696 return (EFI_DEVICE_PATH_PROTOCOL *) Vlan;
2697}
2698
2699/**
2700 Converts a media text device path node to media device path structure.
2701
2702 @param TextDeviceNode The input Text device path node.
2703
2704 @return A pointer to media device path structure.
2705
2706**/
2707EFI_DEVICE_PATH_PROTOCOL *
2708DevPathFromTextMediaPath (
2709 IN CHAR16 *TextDeviceNode
2710 )
2711{
2712 return DevPathFromTextGenericPath (MEDIA_DEVICE_PATH, TextDeviceNode);
2713}
2714
2715/**
2716 Converts a text device path node to HD device path structure.
2717
2718 @param TextDeviceNode The input Text device path node.
2719
2720 @return A pointer to the newly-created HD device path structure.
2721
2722**/
2723EFI_DEVICE_PATH_PROTOCOL *
2724DevPathFromTextHD (
2725 IN CHAR16 *TextDeviceNode
2726 )
2727{
2728 CHAR16 *PartitionStr;
2729 CHAR16 *TypeStr;
2730 CHAR16 *SignatureStr;
2731 CHAR16 *StartStr;
2732 CHAR16 *SizeStr;
2733 UINT32 Signature32;
2734 EFI_GUID SignatureGuid;
2735 HARDDRIVE_DEVICE_PATH *Hd;
2736
2737 PartitionStr = GetNextParamStr (&TextDeviceNode);
2738 TypeStr = GetNextParamStr (&TextDeviceNode);
2739 SignatureStr = GetNextParamStr (&TextDeviceNode);
2740 StartStr = GetNextParamStr (&TextDeviceNode);
2741 SizeStr = GetNextParamStr (&TextDeviceNode);
2742 Hd = (HARDDRIVE_DEVICE_PATH *) CreateDeviceNode (
2743 MEDIA_DEVICE_PATH,
2744 MEDIA_HARDDRIVE_DP,
2745 (UINT16) sizeof (HARDDRIVE_DEVICE_PATH)
2746 );
2747
2748 Hd->PartitionNumber = (UINT32) Strtoi (PartitionStr);
2749
2750 ZeroMem (Hd->Signature, 16);
2751 Hd->MBRType = (UINT8) 0;
2752
2753 if (StrCmp (TypeStr, L"MBR") == 0) {
2754 Hd->SignatureType = SIGNATURE_TYPE_MBR;
2755 Hd->MBRType = 0x01;
2756
2757 Signature32 = (UINT32) Strtoi (SignatureStr);
2758 CopyMem (Hd->Signature, &Signature32, sizeof (UINT32));
2759 } else if (StrCmp (TypeStr, L"GPT") == 0) {
2760 Hd->SignatureType = SIGNATURE_TYPE_GUID;
2761 Hd->MBRType = 0x02;
2762
2763 StrToGuid (SignatureStr, &SignatureGuid);
2764 CopyMem (Hd->Signature, &SignatureGuid, sizeof (EFI_GUID));
2765 } else {
2766 Hd->SignatureType = (UINT8) Strtoi (TypeStr);
2767 }
2768
2769 Strtoi64 (StartStr, &Hd->PartitionStart);
2770 Strtoi64 (SizeStr, &Hd->PartitionSize);
2771
2772 return (EFI_DEVICE_PATH_PROTOCOL *) Hd;
2773}
2774
2775/**
2776 Converts a text device path node to CDROM device path structure.
2777
2778 @param TextDeviceNode The input Text device path node.
2779
2780 @return A pointer to the newly-created CDROM device path structure.
2781
2782**/
2783EFI_DEVICE_PATH_PROTOCOL *
2784DevPathFromTextCDROM (
2785 IN CHAR16 *TextDeviceNode
2786 )
2787{
2788 CHAR16 *EntryStr;
2789 CHAR16 *StartStr;
2790 CHAR16 *SizeStr;
2791 CDROM_DEVICE_PATH *CDROMDevPath;
2792
2793 EntryStr = GetNextParamStr (&TextDeviceNode);
2794 StartStr = GetNextParamStr (&TextDeviceNode);
2795 SizeStr = GetNextParamStr (&TextDeviceNode);
2796 CDROMDevPath = (CDROM_DEVICE_PATH *) CreateDeviceNode (
2797 MEDIA_DEVICE_PATH,
2798 MEDIA_CDROM_DP,
2799 (UINT16) sizeof (CDROM_DEVICE_PATH)
2800 );
2801
2802 CDROMDevPath->BootEntry = (UINT32) Strtoi (EntryStr);
2803 Strtoi64 (StartStr, &CDROMDevPath->PartitionStart);
2804 Strtoi64 (SizeStr, &CDROMDevPath->PartitionSize);
2805
2806 return (EFI_DEVICE_PATH_PROTOCOL *) CDROMDevPath;
2807}
2808
2809/**
2810 Converts a text device path node to Vendor-defined media device path structure.
2811
2812 @param TextDeviceNode The input Text device path node.
2813
2814 @return A pointer to the newly-created Vendor-defined media device path structure.
2815
2816**/
2817EFI_DEVICE_PATH_PROTOCOL *
2818DevPathFromTextVenMedia (
2819 IN CHAR16 *TextDeviceNode
2820 )
2821{
2822 return ConvertFromTextVendor (
2823 TextDeviceNode,
2824 MEDIA_DEVICE_PATH,
2825 MEDIA_VENDOR_DP
2826 );
2827}
2828
2829/**
2830 Converts a text device path node to File device path structure.
2831
2832 @param TextDeviceNode The input Text device path node.
2833
2834 @return A pointer to the newly-created File device path structure.
2835
2836**/
2837EFI_DEVICE_PATH_PROTOCOL *
2838DevPathFromTextFilePath (
2839 IN CHAR16 *TextDeviceNode
2840 )
2841{
2842 FILEPATH_DEVICE_PATH *File;
2843
2844 File = (FILEPATH_DEVICE_PATH *) CreateDeviceNode (
2845 MEDIA_DEVICE_PATH,
2846 MEDIA_FILEPATH_DP,
2847 (UINT16) (sizeof (FILEPATH_DEVICE_PATH) + StrLen (TextDeviceNode) * 2)
2848 );
2849
2850 StrCpy (File->PathName, TextDeviceNode);
2851
2852 return (EFI_DEVICE_PATH_PROTOCOL *) File;
2853}
2854
2855/**
2856 Converts a text device path node to Media protocol device path structure.
2857
2858 @param TextDeviceNode The input Text device path node.
2859
2860 @return A pointer to the newly-created Media protocol device path structure.
2861
2862**/
2863EFI_DEVICE_PATH_PROTOCOL *
2864DevPathFromTextMedia (
2865 IN CHAR16 *TextDeviceNode
2866 )
2867{
2868 CHAR16 *GuidStr;
2869 MEDIA_PROTOCOL_DEVICE_PATH *Media;
2870
2871 GuidStr = GetNextParamStr (&TextDeviceNode);
2872 Media = (MEDIA_PROTOCOL_DEVICE_PATH *) CreateDeviceNode (
2873 MEDIA_DEVICE_PATH,
2874 MEDIA_PROTOCOL_DP,
2875 (UINT16) sizeof (MEDIA_PROTOCOL_DEVICE_PATH)
2876 );
2877
2878 StrToGuid (GuidStr, &Media->Protocol);
2879
2880 return (EFI_DEVICE_PATH_PROTOCOL *) Media;
2881}
2882
2883/**
2884 Converts a text device path node to firmware volume device path structure.
2885
2886 @param TextDeviceNode The input Text device path node.
2887
2888 @return A pointer to the newly-created firmware volume device path structure.
2889
2890**/
2891EFI_DEVICE_PATH_PROTOCOL *
2892DevPathFromTextFv (
2893 IN CHAR16 *TextDeviceNode
2894 )
2895{
2896 CHAR16 *GuidStr;
2897 MEDIA_FW_VOL_DEVICE_PATH *Fv;
2898
2899 GuidStr = GetNextParamStr (&TextDeviceNode);
2900 Fv = (MEDIA_FW_VOL_DEVICE_PATH *) CreateDeviceNode (
2901 MEDIA_DEVICE_PATH,
2902 MEDIA_PIWG_FW_VOL_DP,
2903 (UINT16) sizeof (MEDIA_FW_VOL_DEVICE_PATH)
2904 );
2905
2906 StrToGuid (GuidStr, &Fv->FvName);
2907
2908 return (EFI_DEVICE_PATH_PROTOCOL *) Fv;
2909}
2910
2911/**
2912 Converts a text device path node to firmware file device path structure.
2913
2914 @param TextDeviceNode The input Text device path node.
2915
2916 @return A pointer to the newly-created firmware file device path structure.
2917
2918**/
2919EFI_DEVICE_PATH_PROTOCOL *
2920DevPathFromTextFvFile (
2921 IN CHAR16 *TextDeviceNode
2922 )
2923{
2924 CHAR16 *GuidStr;
2925 MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *FvFile;
2926
2927 GuidStr = GetNextParamStr (&TextDeviceNode);
2928 FvFile = (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) CreateDeviceNode (
2929 MEDIA_DEVICE_PATH,
2930 MEDIA_PIWG_FW_FILE_DP,
2931 (UINT16) sizeof (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH)
2932 );
2933
2934 StrToGuid (GuidStr, &FvFile->FvFileName);
2935
2936 return (EFI_DEVICE_PATH_PROTOCOL *) FvFile;
2937}
2938
2939/**
2940 Converts a text device path node to text relative offset device path structure.
2941
2942 @param TextDeviceNode The input Text device path node.
2943
2944 @return A pointer to the newly-created Text device path structure.
2945
2946**/
2947EFI_DEVICE_PATH_PROTOCOL *
2948DevPathFromTextRelativeOffsetRange (
2949 IN CHAR16 *TextDeviceNode
2950 )
2951{
2952 CHAR16 *StartingOffsetStr;
2953 CHAR16 *EndingOffsetStr;
2954 MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH *Offset;
2955
2956 StartingOffsetStr = GetNextParamStr (&TextDeviceNode);
2957 EndingOffsetStr = GetNextParamStr (&TextDeviceNode);
2958 Offset = (MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH *) CreateDeviceNode (
2959 MEDIA_DEVICE_PATH,
2960 MEDIA_RELATIVE_OFFSET_RANGE_DP,
2961 (UINT16) sizeof (MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH)
2962 );
2963
2964 Strtoi64 (StartingOffsetStr, &Offset->StartingOffset);
2965 Strtoi64 (EndingOffsetStr, &Offset->EndingOffset);
2966
2967 return (EFI_DEVICE_PATH_PROTOCOL *) Offset;
2968}
2969
2970
2971/**
2972 Converts a BBS text device path node to BBS device path structure.
2973
2974 @param TextDeviceNode The input Text device path node.
2975
2976 @return A pointer to BBS device path structure.
2977
2978**/
2979EFI_DEVICE_PATH_PROTOCOL *
2980DevPathFromTextBbsPath (
2981 IN CHAR16 *TextDeviceNode
2982 )
2983{
2984 return DevPathFromTextGenericPath (BBS_DEVICE_PATH, TextDeviceNode);
2985}
2986
2987/**
2988 Converts a text device path node to BIOS Boot Specification device path structure.
2989
2990 @param TextDeviceNode The input Text device path node.
2991
2992 @return A pointer to the newly-created BIOS Boot Specification device path structure.
2993
2994**/
2995EFI_DEVICE_PATH_PROTOCOL *
2996DevPathFromTextBBS (
2997 IN CHAR16 *TextDeviceNode
2998 )
2999{
3000 CHAR16 *TypeStr;
3001 CHAR16 *IdStr;
3002 CHAR16 *FlagsStr;
3003 CHAR8 *AsciiStr;
3004 BBS_BBS_DEVICE_PATH *Bbs;
3005
3006 TypeStr = GetNextParamStr (&TextDeviceNode);
3007 IdStr = GetNextParamStr (&TextDeviceNode);
3008 FlagsStr = GetNextParamStr (&TextDeviceNode);
3009 Bbs = (BBS_BBS_DEVICE_PATH *) CreateDeviceNode (
3010 BBS_DEVICE_PATH,
3011 BBS_BBS_DP,
3012 (UINT16) (sizeof (BBS_BBS_DEVICE_PATH) + StrLen (IdStr))
3013 );
3014
3015 if (StrCmp (TypeStr, L"Floppy") == 0) {
3016 Bbs->DeviceType = BBS_TYPE_FLOPPY;
3017 } else if (StrCmp (TypeStr, L"HD") == 0) {
3018 Bbs->DeviceType = BBS_TYPE_HARDDRIVE;
3019 } else if (StrCmp (TypeStr, L"CDROM") == 0) {
3020 Bbs->DeviceType = BBS_TYPE_CDROM;
3021 } else if (StrCmp (TypeStr, L"PCMCIA") == 0) {
3022 Bbs->DeviceType = BBS_TYPE_PCMCIA;
3023 } else if (StrCmp (TypeStr, L"USB") == 0) {
3024 Bbs->DeviceType = BBS_TYPE_USB;
3025 } else if (StrCmp (TypeStr, L"Network") == 0) {
3026 Bbs->DeviceType = BBS_TYPE_EMBEDDED_NETWORK;
3027 } else {
3028 Bbs->DeviceType = (UINT16) Strtoi (TypeStr);
3029 }
3030
3031 AsciiStr = Bbs->String;
3032 StrToAscii (IdStr, &AsciiStr);
3033
3034 Bbs->StatusFlag = (UINT16) Strtoi (FlagsStr);
3035
3036 return (EFI_DEVICE_PATH_PROTOCOL *) Bbs;
3037}
3038
3039/**
3040 Converts a text device path node to SATA device path structure.
3041
3042 @param TextDeviceNode The input Text device path node.
3043
3044 @return A pointer to the newly-created SATA device path structure.
3045
3046**/
3047EFI_DEVICE_PATH_PROTOCOL *
3048DevPathFromTextSata (
3049 IN CHAR16 *TextDeviceNode
3050 )
3051{
3052 SATA_DEVICE_PATH *Sata;
3053 CHAR16 *Param1;
3054 CHAR16 *Param2;
3055 CHAR16 *Param3;
3056
3057 Param1 = GetNextParamStr (&TextDeviceNode);
3058 Param2 = GetNextParamStr (&TextDeviceNode);
3059 Param3 = GetNextParamStr (&TextDeviceNode);
3060
3061 Sata = (SATA_DEVICE_PATH *) CreateDeviceNode (
3062 MESSAGING_DEVICE_PATH,
3063 MSG_SATA_DP,
3064 (UINT16) sizeof (SATA_DEVICE_PATH)
3065 );
3066 Sata->HBAPortNumber = (UINT16) Strtoi (Param1);
3067 Sata->PortMultiplierPortNumber = (UINT16) Strtoi (Param2);
3068 Sata->Lun = (UINT16) Strtoi (Param3);
3069
3070 return (EFI_DEVICE_PATH_PROTOCOL *) Sata;
3071}
3072
3073GLOBAL_REMOVE_IF_UNREFERENCED DEVICE_PATH_FROM_TEXT_TABLE mUefiDevicePathLibDevPathFromTextTable[] = {
3074 {L"Path", DevPathFromTextPath },
3075
3076 {L"HardwarePath", DevPathFromTextHardwarePath },
3077 {L"Pci", DevPathFromTextPci },
3078 {L"PcCard", DevPathFromTextPcCard },
3079 {L"MemoryMapped", DevPathFromTextMemoryMapped },
3080 {L"VenHw", DevPathFromTextVenHw },
3081 {L"Ctrl", DevPathFromTextCtrl },
3082
3083 {L"AcpiPath", DevPathFromTextAcpiPath },
3084 {L"Acpi", DevPathFromTextAcpi },
3085 {L"PciRoot", DevPathFromTextPciRoot },
3086 {L"PcieRoot", DevPathFromTextPcieRoot },
3087 {L"Floppy", DevPathFromTextFloppy },
3088 {L"Keyboard", DevPathFromTextKeyboard },
3089 {L"Serial", DevPathFromTextSerial },
3090 {L"ParallelPort", DevPathFromTextParallelPort },
3091 {L"AcpiEx", DevPathFromTextAcpiEx },
3092 {L"AcpiExp", DevPathFromTextAcpiExp },
3093 {L"AcpiAdr", DevPathFromTextAcpiAdr },
3094
3095 {L"Msg", DevPathFromTextMsg },
3096 {L"Ata", DevPathFromTextAta },
3097 {L"Scsi", DevPathFromTextScsi },
3098 {L"Fibre", DevPathFromTextFibre },
3099 {L"FibreEx", DevPathFromTextFibreEx },
3100 {L"I1394", DevPathFromText1394 },
3101 {L"USB", DevPathFromTextUsb },
3102 {L"I2O", DevPathFromTextI2O },
3103 {L"Infiniband", DevPathFromTextInfiniband },
3104 {L"VenMsg", DevPathFromTextVenMsg },
3105 {L"VenPcAnsi", DevPathFromTextVenPcAnsi },
3106 {L"VenVt100", DevPathFromTextVenVt100 },
3107 {L"VenVt100Plus", DevPathFromTextVenVt100Plus },
3108 {L"VenUtf8", DevPathFromTextVenUtf8 },
3109 {L"UartFlowCtrl", DevPathFromTextUartFlowCtrl },
3110 {L"SAS", DevPathFromTextSAS },
3111 {L"SasEx", DevPathFromTextSasEx },
3112 {L"NVMe", DevPathFromTextNVMe },
3113 {L"UFS", DevPathFromTextUfs },
3114 {L"DebugPort", DevPathFromTextDebugPort },
3115 {L"MAC", DevPathFromTextMAC },
3116 {L"IPv4", DevPathFromTextIPv4 },
3117 {L"IPv6", DevPathFromTextIPv6 },
3118 {L"Uart", DevPathFromTextUart },
3119 {L"UsbClass", DevPathFromTextUsbClass },
3120 {L"UsbAudio", DevPathFromTextUsbAudio },
3121 {L"UsbCDCControl", DevPathFromTextUsbCDCControl },
3122 {L"UsbHID", DevPathFromTextUsbHID },
3123 {L"UsbImage", DevPathFromTextUsbImage },
3124 {L"UsbPrinter", DevPathFromTextUsbPrinter },
3125 {L"UsbMassStorage", DevPathFromTextUsbMassStorage },
3126 {L"UsbHub", DevPathFromTextUsbHub },
3127 {L"UsbCDCData", DevPathFromTextUsbCDCData },
3128 {L"UsbSmartCard", DevPathFromTextUsbSmartCard },
3129 {L"UsbVideo", DevPathFromTextUsbVideo },
3130 {L"UsbDiagnostic", DevPathFromTextUsbDiagnostic },
3131 {L"UsbWireless", DevPathFromTextUsbWireless },
3132 {L"UsbDeviceFirmwareUpdate", DevPathFromTextUsbDeviceFirmwareUpdate },
3133 {L"UsbIrdaBridge", DevPathFromTextUsbIrdaBridge },
3134 {L"UsbTestAndMeasurement", DevPathFromTextUsbTestAndMeasurement },
3135 {L"UsbWwid", DevPathFromTextUsbWwid },
3136 {L"Unit", DevPathFromTextUnit },
3137 {L"iSCSI", DevPathFromTextiSCSI },
3138 {L"Vlan", DevPathFromTextVlan },
3139
3140 {L"MediaPath", DevPathFromTextMediaPath },
3141 {L"HD", DevPathFromTextHD },
3142 {L"CDROM", DevPathFromTextCDROM },
3143 {L"VenMedia", DevPathFromTextVenMedia },
3144 {L"Media", DevPathFromTextMedia },
3145 {L"Fv", DevPathFromTextFv },
3146 {L"FvFile", DevPathFromTextFvFile },
3147 {L"Offset", DevPathFromTextRelativeOffsetRange },
3148
3149 {L"BbsPath", DevPathFromTextBbsPath },
3150 {L"BBS", DevPathFromTextBBS },
3151 {L"Sata", DevPathFromTextSata },
3152 {NULL, NULL}
3153};
3154
3155/**
3156 Convert text to the binary representation of a device node.
3157
3158 @param TextDeviceNode TextDeviceNode points to the text representation of a device
3159 node. Conversion starts with the first character and continues
3160 until the first non-device node character.
3161
3162 @return A pointer to the EFI device node or NULL if TextDeviceNode is NULL or there was
3163 insufficient memory or text unsupported.
3164
3165**/
3166EFI_DEVICE_PATH_PROTOCOL *
3167EFIAPI
3168UefiDevicePathLibConvertTextToDeviceNode (
3169 IN CONST CHAR16 *TextDeviceNode
3170 )
3171{
3172 DEVICE_PATH_FROM_TEXT FromText;
3173 CHAR16 *ParamStr;
3174 EFI_DEVICE_PATH_PROTOCOL *DeviceNode;
3175 CHAR16 *DeviceNodeStr;
3176 UINTN Index;
3177
3178 if ((TextDeviceNode == NULL) || (IS_NULL (*TextDeviceNode))) {
3179 return NULL;
3180 }
3181
3182 ParamStr = NULL;
3183 FromText = NULL;
3184 DeviceNodeStr = UefiDevicePathLibStrDuplicate (TextDeviceNode);
3185 ASSERT (DeviceNodeStr != NULL);
3186
3187 for (Index = 0; mUefiDevicePathLibDevPathFromTextTable[Index].Function != NULL; Index++) {
3188 ParamStr = GetParamByNodeName (DeviceNodeStr, mUefiDevicePathLibDevPathFromTextTable[Index].DevicePathNodeText);
3189 if (ParamStr != NULL) {
3190 FromText = mUefiDevicePathLibDevPathFromTextTable[Index].Function;
3191 break;
3192 }
3193 }
3194
3195 if (FromText == NULL) {
3196 //
3197 // A file path
3198 //
3199 FromText = DevPathFromTextFilePath;
3200 DeviceNode = FromText (DeviceNodeStr);
3201 } else {
3202 DeviceNode = FromText (ParamStr);
3203 FreePool (ParamStr);
3204 }
3205
3206 FreePool (DeviceNodeStr);
3207
3208 return DeviceNode;
3209}
3210
3211/**
3212 Convert text to the binary representation of a device path.
3213
3214
3215 @param TextDevicePath TextDevicePath points to the text representation of a device
3216 path. Conversion starts with the first character and continues
3217 until the first non-device node character.
3218
3219 @return A pointer to the allocated device path or NULL if TextDeviceNode is NULL or
3220 there was insufficient memory.
3221
3222**/
3223EFI_DEVICE_PATH_PROTOCOL *
3224EFIAPI
3225UefiDevicePathLibConvertTextToDevicePath (
3226 IN CONST CHAR16 *TextDevicePath
3227 )
3228{
3229 EFI_DEVICE_PATH_PROTOCOL *DeviceNode;
3230 EFI_DEVICE_PATH_PROTOCOL *NewDevicePath;
3231 CHAR16 *DevicePathStr;
3232 CHAR16 *Str;
3233 CHAR16 *DeviceNodeStr;
3234 BOOLEAN IsInstanceEnd;
3235 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
3236
3237 if ((TextDevicePath == NULL) || (IS_NULL (*TextDevicePath))) {
3238 return NULL;
3239 }
3240
3241 DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) AllocatePool (END_DEVICE_PATH_LENGTH);
3242 ASSERT (DevicePath != NULL);
3243 SetDevicePathEndNode (DevicePath);
3244
3245 DevicePathStr = UefiDevicePathLibStrDuplicate (TextDevicePath);
3246
3247 Str = DevicePathStr;
3248 while ((DeviceNodeStr = GetNextDeviceNodeStr (&Str, &IsInstanceEnd)) != NULL) {
3249 DeviceNode = UefiDevicePathLibConvertTextToDeviceNode (DeviceNodeStr);
3250
3251 NewDevicePath = AppendDevicePathNode (DevicePath, DeviceNode);
3252 FreePool (DevicePath);
3253 FreePool (DeviceNode);
3254 DevicePath = NewDevicePath;
3255
3256 if (IsInstanceEnd) {
3257 DeviceNode = (EFI_DEVICE_PATH_PROTOCOL *) AllocatePool (END_DEVICE_PATH_LENGTH);
3258 ASSERT (DeviceNode != NULL);
3259 SetDevicePathEndNode (DeviceNode);
3260
3261 NewDevicePath = AppendDevicePathNode (DevicePath, DeviceNode);
3262 FreePool (DevicePath);
3263 FreePool (DeviceNode);
3264 DevicePath = NewDevicePath;
3265 }
3266 }
3267
3268 FreePool (DevicePathStr);
3269 return DevicePath;
3270}
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette