1 /** @file
2 DevicePathFromText protocol as defined in the UEFI 2.0 specification.
3
4 Copyright (c) 2013 - 2015, 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
9
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.
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 **/
26 CHAR16 *
UefiDevicePathLibStrDuplicate(IN CONST CHAR16 * Src)27 UefiDevicePathLibStrDuplicate (
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 **/
45 CHAR16 *
GetParamByNodeName(IN CHAR16 * Str,IN CHAR16 * NodeName)46 GetParamByNodeName (
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 **/
113 CHAR16 *
SplitStr(IN OUT CHAR16 ** List,IN CHAR16 Separator)114 SplitStr (
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 **/
163 CHAR16 *
GetNextParamStr(IN OUT CHAR16 ** List)164 GetNextParamStr (
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 **/
183 CHAR16 *
GetNextDeviceNodeStr(IN OUT CHAR16 ** DevicePath,OUT BOOLEAN * IsInstanceEnd)184 GetNextDeviceNodeStr (
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 **/
265 BOOLEAN
IsHexStr(IN CHAR16 * Str)266 IsHexStr (
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 **/
295 UINTN
Strtoi(IN CHAR16 * Str)296 Strtoi (
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 **/
315 VOID
Strtoi64(IN CHAR16 * Str,OUT UINT64 * Data)316 Strtoi64 (
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 **/
338 EFI_STATUS
StrToBuf(OUT UINT8 * Buf,IN UINTN BufferLength,IN CHAR16 * Str)339 StrToBuf (
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 **/
399 EFI_STATUS
StrToGuid(IN CHAR16 * Str,OUT EFI_GUID * Guid)400 StrToGuid (
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 **/
473 VOID
StrToIPv4Addr(IN OUT CHAR16 ** Str,OUT EFI_IPv4_ADDRESS * IPv4Addr)474 StrToIPv4Addr (
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 **/
493 VOID
StrToIPv6Addr(IN OUT CHAR16 ** Str,OUT EFI_IPv6_ADDRESS * IPv6Addr)494 StrToIPv6Addr (
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 **/
517 VOID
StrToAscii(IN CHAR16 * Str,IN OUT CHAR8 ** AsciiStr)518 StrToAscii (
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 **/
545 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextGenericPath(IN UINT8 Type,IN CHAR16 * TextDeviceNode)546 DevPathFromTextGenericPath (
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 **/
584 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextPath(IN CHAR16 * TextDeviceNode)585 DevPathFromTextPath (
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 **/
604 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextHardwarePath(IN CHAR16 * TextDeviceNode)605 DevPathFromTextHardwarePath (
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 **/
620 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextPci(IN CHAR16 * TextDeviceNode)621 DevPathFromTextPci (
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 **/
651 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextPcCard(IN CHAR16 * TextDeviceNode)652 DevPathFromTextPcCard (
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 **/
679 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextMemoryMapped(IN CHAR16 * TextDeviceNode)680 DevPathFromTextMemoryMapped (
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 **/
716 EFI_DEVICE_PATH_PROTOCOL *
ConvertFromTextVendor(IN CHAR16 * TextDeviceNode,IN UINT8 Type,IN UINT8 SubType)717 ConvertFromTextVendor (
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 **/
757 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextVenHw(IN CHAR16 * TextDeviceNode)758 DevPathFromTextVenHw (
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 **/
777 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextCtrl(IN CHAR16 * TextDeviceNode)778 DevPathFromTextCtrl (
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 text device path node to BMC device path structure.
798
799 @param TextDeviceNode The input Text device path node.
800
801 @return A pointer to the newly-created BMC device path structure.
802
803 **/
804 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextBmc(IN CHAR16 * TextDeviceNode)805 DevPathFromTextBmc (
806 IN CHAR16 *TextDeviceNode
807 )
808 {
809 CHAR16 *InterfaceTypeStr;
810 CHAR16 *BaseAddressStr;
811 BMC_DEVICE_PATH *BmcDp;
812
813 InterfaceTypeStr = GetNextParamStr (&TextDeviceNode);
814 BaseAddressStr = GetNextParamStr (&TextDeviceNode);
815 BmcDp = (BMC_DEVICE_PATH *) CreateDeviceNode (
816 HARDWARE_DEVICE_PATH,
817 HW_BMC_DP,
818 (UINT16) sizeof (BMC_DEVICE_PATH)
819 );
820
821 BmcDp->InterfaceType = (UINT8) Strtoi (InterfaceTypeStr);
822 WriteUnaligned64 (
823 (UINT64 *) (&BmcDp->BaseAddress),
824 StrHexToUint64 (BaseAddressStr)
825 );
826
827 return (EFI_DEVICE_PATH_PROTOCOL *) BmcDp;
828 }
829
830 /**
831 Converts a generic ACPI text device path node to ACPI device path structure.
832
833 @param TextDeviceNode The input Text device path node.
834
835 @return A pointer to ACPI device path structure.
836
837 **/
838 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextAcpiPath(IN CHAR16 * TextDeviceNode)839 DevPathFromTextAcpiPath (
840 IN CHAR16 *TextDeviceNode
841 )
842 {
843 return DevPathFromTextGenericPath (ACPI_DEVICE_PATH, TextDeviceNode);
844 }
845
846 /**
847 Converts a string to EisaId.
848
849 @param Text The input string.
850
851 @return UINT32 EISA ID.
852 **/
853 UINT32
EisaIdFromText(IN CHAR16 * Text)854 EisaIdFromText (
855 IN CHAR16 *Text
856 )
857 {
858 return (((Text[0] - 'A' + 1) & 0x1f) << 10)
859 + (((Text[1] - 'A' + 1) & 0x1f) << 5)
860 + (((Text[2] - 'A' + 1) & 0x1f) << 0)
861 + (UINT32) (StrHexToUintn (&Text[3]) << 16)
862 ;
863 }
864
865 /**
866 Converts a text device path node to ACPI HID device path structure.
867
868 @param TextDeviceNode The input Text device path node.
869
870 @return A pointer to the newly-created ACPI HID device path structure.
871
872 **/
873 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextAcpi(IN CHAR16 * TextDeviceNode)874 DevPathFromTextAcpi (
875 IN CHAR16 *TextDeviceNode
876 )
877 {
878 CHAR16 *HIDStr;
879 CHAR16 *UIDStr;
880 ACPI_HID_DEVICE_PATH *Acpi;
881
882 HIDStr = GetNextParamStr (&TextDeviceNode);
883 UIDStr = GetNextParamStr (&TextDeviceNode);
884 Acpi = (ACPI_HID_DEVICE_PATH *) CreateDeviceNode (
885 ACPI_DEVICE_PATH,
886 ACPI_DP,
887 (UINT16) sizeof (ACPI_HID_DEVICE_PATH)
888 );
889
890 Acpi->HID = EisaIdFromText (HIDStr);
891 Acpi->UID = (UINT32) Strtoi (UIDStr);
892
893 return (EFI_DEVICE_PATH_PROTOCOL *) Acpi;
894 }
895
896 /**
897 Converts a text device path node to ACPI HID device path structure.
898
899 @param TextDeviceNode The input Text device path node.
900 @param PnPId The input plug and play identification.
901
902 @return A pointer to the newly-created ACPI HID device path structure.
903
904 **/
905 EFI_DEVICE_PATH_PROTOCOL *
ConvertFromTextAcpi(IN CHAR16 * TextDeviceNode,IN UINT32 PnPId)906 ConvertFromTextAcpi (
907 IN CHAR16 *TextDeviceNode,
908 IN UINT32 PnPId
909 )
910 {
911 CHAR16 *UIDStr;
912 ACPI_HID_DEVICE_PATH *Acpi;
913
914 UIDStr = GetNextParamStr (&TextDeviceNode);
915 Acpi = (ACPI_HID_DEVICE_PATH *) CreateDeviceNode (
916 ACPI_DEVICE_PATH,
917 ACPI_DP,
918 (UINT16) sizeof (ACPI_HID_DEVICE_PATH)
919 );
920
921 Acpi->HID = EFI_PNP_ID (PnPId);
922 Acpi->UID = (UINT32) Strtoi (UIDStr);
923
924 return (EFI_DEVICE_PATH_PROTOCOL *) Acpi;
925 }
926
927 /**
928 Converts a text device path node to PCI root device path structure.
929
930 @param TextDeviceNode The input Text device path node.
931
932 @return A pointer to the newly-created PCI root device path structure.
933
934 **/
935 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextPciRoot(IN CHAR16 * TextDeviceNode)936 DevPathFromTextPciRoot (
937 IN CHAR16 *TextDeviceNode
938 )
939 {
940 return ConvertFromTextAcpi (TextDeviceNode, 0x0a03);
941 }
942
943 /**
944 Converts a text device path node to PCIE root device path structure.
945
946 @param TextDeviceNode The input Text device path node.
947
948 @return A pointer to the newly-created PCIE root device path structure.
949
950 **/
951 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextPcieRoot(IN CHAR16 * TextDeviceNode)952 DevPathFromTextPcieRoot (
953 IN CHAR16 *TextDeviceNode
954 )
955 {
956 return ConvertFromTextAcpi (TextDeviceNode, 0x0a08);
957 }
958
959 /**
960 Converts a text device path node to Floppy device path structure.
961
962 @param TextDeviceNode The input Text device path node.
963
964 @return A pointer to the newly-created Floppy device path structure.
965
966 **/
967 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextFloppy(IN CHAR16 * TextDeviceNode)968 DevPathFromTextFloppy (
969 IN CHAR16 *TextDeviceNode
970 )
971 {
972 return ConvertFromTextAcpi (TextDeviceNode, 0x0604);
973 }
974
975 /**
976 Converts a text device path node to Keyboard device path structure.
977
978 @param TextDeviceNode The input Text device path node.
979
980 @return A pointer to the newly-created Keyboard device path structure.
981
982 **/
983 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextKeyboard(IN CHAR16 * TextDeviceNode)984 DevPathFromTextKeyboard (
985 IN CHAR16 *TextDeviceNode
986 )
987 {
988 return ConvertFromTextAcpi (TextDeviceNode, 0x0301);
989 }
990
991 /**
992 Converts a text device path node to Serial device path structure.
993
994 @param TextDeviceNode The input Text device path node.
995
996 @return A pointer to the newly-created Serial device path structure.
997
998 **/
999 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextSerial(IN CHAR16 * TextDeviceNode)1000 DevPathFromTextSerial (
1001 IN CHAR16 *TextDeviceNode
1002 )
1003 {
1004 return ConvertFromTextAcpi (TextDeviceNode, 0x0501);
1005 }
1006
1007 /**
1008 Converts a text device path node to Parallel Port device path structure.
1009
1010 @param TextDeviceNode The input Text device path node.
1011
1012 @return A pointer to the newly-created Parallel Port device path structure.
1013
1014 **/
1015 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextParallelPort(IN CHAR16 * TextDeviceNode)1016 DevPathFromTextParallelPort (
1017 IN CHAR16 *TextDeviceNode
1018 )
1019 {
1020 return ConvertFromTextAcpi (TextDeviceNode, 0x0401);
1021 }
1022
1023 /**
1024 Converts a text device path node to ACPI extension device path structure.
1025
1026 @param TextDeviceNode The input Text device path node.
1027
1028 @return A pointer to the newly-created ACPI extension device path structure.
1029
1030 **/
1031 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextAcpiEx(IN CHAR16 * TextDeviceNode)1032 DevPathFromTextAcpiEx (
1033 IN CHAR16 *TextDeviceNode
1034 )
1035 {
1036 CHAR16 *HIDStr;
1037 CHAR16 *CIDStr;
1038 CHAR16 *UIDStr;
1039 CHAR16 *HIDSTRStr;
1040 CHAR16 *CIDSTRStr;
1041 CHAR16 *UIDSTRStr;
1042 CHAR8 *AsciiStr;
1043 UINT16 Length;
1044 ACPI_EXTENDED_HID_DEVICE_PATH *AcpiEx;
1045
1046 HIDStr = GetNextParamStr (&TextDeviceNode);
1047 CIDStr = GetNextParamStr (&TextDeviceNode);
1048 UIDStr = GetNextParamStr (&TextDeviceNode);
1049 HIDSTRStr = GetNextParamStr (&TextDeviceNode);
1050 CIDSTRStr = GetNextParamStr (&TextDeviceNode);
1051 UIDSTRStr = GetNextParamStr (&TextDeviceNode);
1052
1053 Length = (UINT16) (sizeof (ACPI_EXTENDED_HID_DEVICE_PATH) + StrLen (HIDSTRStr) + 1);
1054 Length = (UINT16) (Length + StrLen (UIDSTRStr) + 1);
1055 Length = (UINT16) (Length + StrLen (CIDSTRStr) + 1);
1056 AcpiEx = (ACPI_EXTENDED_HID_DEVICE_PATH *) CreateDeviceNode (
1057 ACPI_DEVICE_PATH,
1058 ACPI_EXTENDED_DP,
1059 Length
1060 );
1061
1062 AcpiEx->HID = EisaIdFromText (HIDStr);
1063 AcpiEx->CID = EisaIdFromText (CIDStr);
1064 AcpiEx->UID = (UINT32) Strtoi (UIDStr);
1065
1066 AsciiStr = (CHAR8 *) ((UINT8 *)AcpiEx + sizeof (ACPI_EXTENDED_HID_DEVICE_PATH));
1067 StrToAscii (HIDSTRStr, &AsciiStr);
1068 StrToAscii (UIDSTRStr, &AsciiStr);
1069 StrToAscii (CIDSTRStr, &AsciiStr);
1070
1071 return (EFI_DEVICE_PATH_PROTOCOL *) AcpiEx;
1072 }
1073
1074 /**
1075 Converts a text device path node to ACPI extension device path structure.
1076
1077 @param TextDeviceNode The input Text device path node.
1078
1079 @return A pointer to the newly-created ACPI extension device path structure.
1080
1081 **/
1082 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextAcpiExp(IN CHAR16 * TextDeviceNode)1083 DevPathFromTextAcpiExp (
1084 IN CHAR16 *TextDeviceNode
1085 )
1086 {
1087 CHAR16 *HIDStr;
1088 CHAR16 *CIDStr;
1089 CHAR16 *UIDSTRStr;
1090 CHAR8 *AsciiStr;
1091 UINT16 Length;
1092 ACPI_EXTENDED_HID_DEVICE_PATH *AcpiEx;
1093
1094 HIDStr = GetNextParamStr (&TextDeviceNode);
1095 CIDStr = GetNextParamStr (&TextDeviceNode);
1096 UIDSTRStr = GetNextParamStr (&TextDeviceNode);
1097 Length = (UINT16) (sizeof (ACPI_EXTENDED_HID_DEVICE_PATH) + StrLen (UIDSTRStr) + 3);
1098 AcpiEx = (ACPI_EXTENDED_HID_DEVICE_PATH *) CreateDeviceNode (
1099 ACPI_DEVICE_PATH,
1100 ACPI_EXTENDED_DP,
1101 Length
1102 );
1103
1104 AcpiEx->HID = EisaIdFromText (HIDStr);
1105 AcpiEx->CID = EisaIdFromText (CIDStr);
1106 AcpiEx->UID = 0;
1107
1108 AsciiStr = (CHAR8 *) ((UINT8 *)AcpiEx + sizeof (ACPI_EXTENDED_HID_DEVICE_PATH));
1109 //
1110 // HID string is NULL
1111 //
1112 *AsciiStr = '\0';
1113 //
1114 // Convert UID string
1115 //
1116 AsciiStr++;
1117 StrToAscii (UIDSTRStr, &AsciiStr);
1118 //
1119 // CID string is NULL
1120 //
1121 *AsciiStr = '\0';
1122
1123 return (EFI_DEVICE_PATH_PROTOCOL *) AcpiEx;
1124 }
1125
1126 /**
1127 Converts a text device path node to ACPI _ADR device path structure.
1128
1129 @param TextDeviceNode The input Text device path node.
1130
1131 @return A pointer to the newly-created ACPI _ADR device path structure.
1132
1133 **/
1134 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextAcpiAdr(IN CHAR16 * TextDeviceNode)1135 DevPathFromTextAcpiAdr (
1136 IN CHAR16 *TextDeviceNode
1137 )
1138 {
1139 CHAR16 *DisplayDeviceStr;
1140 ACPI_ADR_DEVICE_PATH *AcpiAdr;
1141 UINTN Index;
1142 UINTN Length;
1143
1144 AcpiAdr = (ACPI_ADR_DEVICE_PATH *) CreateDeviceNode (
1145 ACPI_DEVICE_PATH,
1146 ACPI_ADR_DP,
1147 (UINT16) sizeof (ACPI_ADR_DEVICE_PATH)
1148 );
1149 ASSERT (AcpiAdr != NULL);
1150
1151 for (Index = 0; ; Index++) {
1152 DisplayDeviceStr = GetNextParamStr (&TextDeviceNode);
1153 if (IS_NULL (*DisplayDeviceStr)) {
1154 break;
1155 }
1156 if (Index > 0) {
1157 Length = DevicePathNodeLength (AcpiAdr);
1158 AcpiAdr = ReallocatePool (
1159 Length,
1160 Length + sizeof (UINT32),
1161 AcpiAdr
1162 );
1163 ASSERT (AcpiAdr != NULL);
1164 SetDevicePathNodeLength (AcpiAdr, Length + sizeof (UINT32));
1165 }
1166
1167 (&AcpiAdr->ADR)[Index] = (UINT32) Strtoi (DisplayDeviceStr);
1168 }
1169
1170 return (EFI_DEVICE_PATH_PROTOCOL *) AcpiAdr;
1171 }
1172
1173 /**
1174 Converts a generic messaging text device path node to messaging device path structure.
1175
1176 @param TextDeviceNode The input Text device path node.
1177
1178 @return A pointer to messaging device path structure.
1179
1180 **/
1181 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextMsg(IN CHAR16 * TextDeviceNode)1182 DevPathFromTextMsg (
1183 IN CHAR16 *TextDeviceNode
1184 )
1185 {
1186 return DevPathFromTextGenericPath (MESSAGING_DEVICE_PATH, TextDeviceNode);
1187 }
1188
1189 /**
1190 Converts a text device path node to Parallel Port device path structure.
1191
1192 @param TextDeviceNode The input Text device path node.
1193
1194 @return A pointer to the newly-created Parallel Port device path structure.
1195
1196 **/
1197 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextAta(IN CHAR16 * TextDeviceNode)1198 DevPathFromTextAta (
1199 IN CHAR16 *TextDeviceNode
1200 )
1201 {
1202 CHAR16 *PrimarySecondaryStr;
1203 CHAR16 *SlaveMasterStr;
1204 CHAR16 *LunStr;
1205 ATAPI_DEVICE_PATH *Atapi;
1206
1207 Atapi = (ATAPI_DEVICE_PATH *) CreateDeviceNode (
1208 MESSAGING_DEVICE_PATH,
1209 MSG_ATAPI_DP,
1210 (UINT16) sizeof (ATAPI_DEVICE_PATH)
1211 );
1212
1213 PrimarySecondaryStr = GetNextParamStr (&TextDeviceNode);
1214 SlaveMasterStr = GetNextParamStr (&TextDeviceNode);
1215 LunStr = GetNextParamStr (&TextDeviceNode);
1216
1217 if (StrCmp (PrimarySecondaryStr, L"Primary") == 0) {
1218 Atapi->PrimarySecondary = 0;
1219 } else if (StrCmp (PrimarySecondaryStr, L"Secondary") == 0) {
1220 Atapi->PrimarySecondary = 1;
1221 } else {
1222 Atapi->PrimarySecondary = (UINT8) Strtoi (PrimarySecondaryStr);
1223 }
1224 if (StrCmp (SlaveMasterStr, L"Master") == 0) {
1225 Atapi->SlaveMaster = 0;
1226 } else if (StrCmp (SlaveMasterStr, L"Slave") == 0) {
1227 Atapi->SlaveMaster = 1;
1228 } else {
1229 Atapi->SlaveMaster = (UINT8) Strtoi (SlaveMasterStr);
1230 }
1231
1232 Atapi->Lun = (UINT16) Strtoi (LunStr);
1233
1234 return (EFI_DEVICE_PATH_PROTOCOL *) Atapi;
1235 }
1236
1237 /**
1238 Converts a text device path node to SCSI device path structure.
1239
1240 @param TextDeviceNode The input Text device path node.
1241
1242 @return A pointer to the newly-created SCSI device path structure.
1243
1244 **/
1245 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextScsi(IN CHAR16 * TextDeviceNode)1246 DevPathFromTextScsi (
1247 IN CHAR16 *TextDeviceNode
1248 )
1249 {
1250 CHAR16 *PunStr;
1251 CHAR16 *LunStr;
1252 SCSI_DEVICE_PATH *Scsi;
1253
1254 PunStr = GetNextParamStr (&TextDeviceNode);
1255 LunStr = GetNextParamStr (&TextDeviceNode);
1256 Scsi = (SCSI_DEVICE_PATH *) CreateDeviceNode (
1257 MESSAGING_DEVICE_PATH,
1258 MSG_SCSI_DP,
1259 (UINT16) sizeof (SCSI_DEVICE_PATH)
1260 );
1261
1262 Scsi->Pun = (UINT16) Strtoi (PunStr);
1263 Scsi->Lun = (UINT16) Strtoi (LunStr);
1264
1265 return (EFI_DEVICE_PATH_PROTOCOL *) Scsi;
1266 }
1267
1268 /**
1269 Converts a text device path node to Fibre device path structure.
1270
1271 @param TextDeviceNode The input Text device path node.
1272
1273 @return A pointer to the newly-created Fibre device path structure.
1274
1275 **/
1276 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextFibre(IN CHAR16 * TextDeviceNode)1277 DevPathFromTextFibre (
1278 IN CHAR16 *TextDeviceNode
1279 )
1280 {
1281 CHAR16 *WWNStr;
1282 CHAR16 *LunStr;
1283 FIBRECHANNEL_DEVICE_PATH *Fibre;
1284
1285 WWNStr = GetNextParamStr (&TextDeviceNode);
1286 LunStr = GetNextParamStr (&TextDeviceNode);
1287 Fibre = (FIBRECHANNEL_DEVICE_PATH *) CreateDeviceNode (
1288 MESSAGING_DEVICE_PATH,
1289 MSG_FIBRECHANNEL_DP,
1290 (UINT16) sizeof (FIBRECHANNEL_DEVICE_PATH)
1291 );
1292
1293 Fibre->Reserved = 0;
1294 Strtoi64 (WWNStr, &Fibre->WWN);
1295 Strtoi64 (LunStr, &Fibre->Lun);
1296
1297 return (EFI_DEVICE_PATH_PROTOCOL *) Fibre;
1298 }
1299
1300 /**
1301 Converts a text device path node to FibreEx device path structure.
1302
1303 @param TextDeviceNode The input Text device path node.
1304
1305 @return A pointer to the newly-created FibreEx device path structure.
1306
1307 **/
1308 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextFibreEx(IN CHAR16 * TextDeviceNode)1309 DevPathFromTextFibreEx (
1310 IN CHAR16 *TextDeviceNode
1311 )
1312 {
1313 CHAR16 *WWNStr;
1314 CHAR16 *LunStr;
1315 FIBRECHANNELEX_DEVICE_PATH *FibreEx;
1316
1317 WWNStr = GetNextParamStr (&TextDeviceNode);
1318 LunStr = GetNextParamStr (&TextDeviceNode);
1319 FibreEx = (FIBRECHANNELEX_DEVICE_PATH *) CreateDeviceNode (
1320 MESSAGING_DEVICE_PATH,
1321 MSG_FIBRECHANNELEX_DP,
1322 (UINT16) sizeof (FIBRECHANNELEX_DEVICE_PATH)
1323 );
1324
1325 FibreEx->Reserved = 0;
1326 Strtoi64 (WWNStr, (UINT64 *) (&FibreEx->WWN));
1327 Strtoi64 (LunStr, (UINT64 *) (&FibreEx->Lun));
1328
1329 *(UINT64 *) (&FibreEx->WWN) = SwapBytes64 (*(UINT64 *) (&FibreEx->WWN));
1330 *(UINT64 *) (&FibreEx->Lun) = SwapBytes64 (*(UINT64 *) (&FibreEx->Lun));
1331
1332 return (EFI_DEVICE_PATH_PROTOCOL *) FibreEx;
1333 }
1334
1335 /**
1336 Converts a text device path node to 1394 device path structure.
1337
1338 @param TextDeviceNode The input Text device path node.
1339
1340 @return A pointer to the newly-created 1394 device path structure.
1341
1342 **/
1343 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromText1394(IN CHAR16 * TextDeviceNode)1344 DevPathFromText1394 (
1345 IN CHAR16 *TextDeviceNode
1346 )
1347 {
1348 CHAR16 *GuidStr;
1349 F1394_DEVICE_PATH *F1394DevPath;
1350
1351 GuidStr = GetNextParamStr (&TextDeviceNode);
1352 F1394DevPath = (F1394_DEVICE_PATH *) CreateDeviceNode (
1353 MESSAGING_DEVICE_PATH,
1354 MSG_1394_DP,
1355 (UINT16) sizeof (F1394_DEVICE_PATH)
1356 );
1357
1358 F1394DevPath->Reserved = 0;
1359 F1394DevPath->Guid = StrHexToUint64 (GuidStr);
1360
1361 return (EFI_DEVICE_PATH_PROTOCOL *) F1394DevPath;
1362 }
1363
1364 /**
1365 Converts a text device path node to USB device path structure.
1366
1367 @param TextDeviceNode The input Text device path node.
1368
1369 @return A pointer to the newly-created USB device path structure.
1370
1371 **/
1372 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsb(IN CHAR16 * TextDeviceNode)1373 DevPathFromTextUsb (
1374 IN CHAR16 *TextDeviceNode
1375 )
1376 {
1377 CHAR16 *PortStr;
1378 CHAR16 *InterfaceStr;
1379 USB_DEVICE_PATH *Usb;
1380
1381 PortStr = GetNextParamStr (&TextDeviceNode);
1382 InterfaceStr = GetNextParamStr (&TextDeviceNode);
1383 Usb = (USB_DEVICE_PATH *) CreateDeviceNode (
1384 MESSAGING_DEVICE_PATH,
1385 MSG_USB_DP,
1386 (UINT16) sizeof (USB_DEVICE_PATH)
1387 );
1388
1389 Usb->ParentPortNumber = (UINT8) Strtoi (PortStr);
1390 Usb->InterfaceNumber = (UINT8) Strtoi (InterfaceStr);
1391
1392 return (EFI_DEVICE_PATH_PROTOCOL *) Usb;
1393 }
1394
1395 /**
1396 Converts a text device path node to I20 device path structure.
1397
1398 @param TextDeviceNode The input Text device path node.
1399
1400 @return A pointer to the newly-created I20 device path structure.
1401
1402 **/
1403 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextI2O(IN CHAR16 * TextDeviceNode)1404 DevPathFromTextI2O (
1405 IN CHAR16 *TextDeviceNode
1406 )
1407 {
1408 CHAR16 *TIDStr;
1409 I2O_DEVICE_PATH *I2ODevPath;
1410
1411 TIDStr = GetNextParamStr (&TextDeviceNode);
1412 I2ODevPath = (I2O_DEVICE_PATH *) CreateDeviceNode (
1413 MESSAGING_DEVICE_PATH,
1414 MSG_I2O_DP,
1415 (UINT16) sizeof (I2O_DEVICE_PATH)
1416 );
1417
1418 I2ODevPath->Tid = (UINT32) Strtoi (TIDStr);
1419
1420 return (EFI_DEVICE_PATH_PROTOCOL *) I2ODevPath;
1421 }
1422
1423 /**
1424 Converts a text device path node to Infini Band device path structure.
1425
1426 @param TextDeviceNode The input Text device path node.
1427
1428 @return A pointer to the newly-created Infini Band device path structure.
1429
1430 **/
1431 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextInfiniband(IN CHAR16 * TextDeviceNode)1432 DevPathFromTextInfiniband (
1433 IN CHAR16 *TextDeviceNode
1434 )
1435 {
1436 CHAR16 *FlagsStr;
1437 CHAR16 *GuidStr;
1438 CHAR16 *SidStr;
1439 CHAR16 *TidStr;
1440 CHAR16 *DidStr;
1441 EFI_GUID PortGid;
1442 INFINIBAND_DEVICE_PATH *InfiniBand;
1443
1444 FlagsStr = GetNextParamStr (&TextDeviceNode);
1445 GuidStr = GetNextParamStr (&TextDeviceNode);
1446 SidStr = GetNextParamStr (&TextDeviceNode);
1447 TidStr = GetNextParamStr (&TextDeviceNode);
1448 DidStr = GetNextParamStr (&TextDeviceNode);
1449 InfiniBand = (INFINIBAND_DEVICE_PATH *) CreateDeviceNode (
1450 MESSAGING_DEVICE_PATH,
1451 MSG_INFINIBAND_DP,
1452 (UINT16) sizeof (INFINIBAND_DEVICE_PATH)
1453 );
1454
1455 InfiniBand->ResourceFlags = (UINT32) Strtoi (FlagsStr);
1456 StrToGuid (GuidStr, &PortGid);
1457 CopyMem (InfiniBand->PortGid, &PortGid, sizeof (EFI_GUID));
1458 Strtoi64 (SidStr, &InfiniBand->ServiceId);
1459 Strtoi64 (TidStr, &InfiniBand->TargetPortId);
1460 Strtoi64 (DidStr, &InfiniBand->DeviceId);
1461
1462 return (EFI_DEVICE_PATH_PROTOCOL *) InfiniBand;
1463 }
1464
1465 /**
1466 Converts a text device path node to Vendor-Defined Messaging device path structure.
1467
1468 @param TextDeviceNode The input Text device path node.
1469
1470 @return A pointer to the newly-created Vendor-Defined Messaging device path structure.
1471
1472 **/
1473 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextVenMsg(IN CHAR16 * TextDeviceNode)1474 DevPathFromTextVenMsg (
1475 IN CHAR16 *TextDeviceNode
1476 )
1477 {
1478 return ConvertFromTextVendor (
1479 TextDeviceNode,
1480 MESSAGING_DEVICE_PATH,
1481 MSG_VENDOR_DP
1482 );
1483 }
1484
1485 /**
1486 Converts a text device path node to Vendor defined PC-ANSI device path structure.
1487
1488 @param TextDeviceNode The input Text device path node.
1489
1490 @return A pointer to the newly-created Vendor defined PC-ANSI device path structure.
1491
1492 **/
1493 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextVenPcAnsi(IN CHAR16 * TextDeviceNode)1494 DevPathFromTextVenPcAnsi (
1495 IN CHAR16 *TextDeviceNode
1496 )
1497 {
1498 VENDOR_DEVICE_PATH *Vendor;
1499
1500 Vendor = (VENDOR_DEVICE_PATH *) CreateDeviceNode (
1501 MESSAGING_DEVICE_PATH,
1502 MSG_VENDOR_DP,
1503 (UINT16) sizeof (VENDOR_DEVICE_PATH));
1504 CopyGuid (&Vendor->Guid, &gEfiPcAnsiGuid);
1505
1506 return (EFI_DEVICE_PATH_PROTOCOL *) Vendor;
1507 }
1508
1509 /**
1510 Converts a text device path node to Vendor defined VT100 device path structure.
1511
1512 @param TextDeviceNode The input Text device path node.
1513
1514 @return A pointer to the newly-created Vendor defined VT100 device path structure.
1515
1516 **/
1517 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextVenVt100(IN CHAR16 * TextDeviceNode)1518 DevPathFromTextVenVt100 (
1519 IN CHAR16 *TextDeviceNode
1520 )
1521 {
1522 VENDOR_DEVICE_PATH *Vendor;
1523
1524 Vendor = (VENDOR_DEVICE_PATH *) CreateDeviceNode (
1525 MESSAGING_DEVICE_PATH,
1526 MSG_VENDOR_DP,
1527 (UINT16) sizeof (VENDOR_DEVICE_PATH));
1528 CopyGuid (&Vendor->Guid, &gEfiVT100Guid);
1529
1530 return (EFI_DEVICE_PATH_PROTOCOL *) Vendor;
1531 }
1532
1533 /**
1534 Converts a text device path node to Vendor defined VT100 Plus device path structure.
1535
1536 @param TextDeviceNode The input Text device path node.
1537
1538 @return A pointer to the newly-created Vendor defined VT100 Plus device path structure.
1539
1540 **/
1541 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextVenVt100Plus(IN CHAR16 * TextDeviceNode)1542 DevPathFromTextVenVt100Plus (
1543 IN CHAR16 *TextDeviceNode
1544 )
1545 {
1546 VENDOR_DEVICE_PATH *Vendor;
1547
1548 Vendor = (VENDOR_DEVICE_PATH *) CreateDeviceNode (
1549 MESSAGING_DEVICE_PATH,
1550 MSG_VENDOR_DP,
1551 (UINT16) sizeof (VENDOR_DEVICE_PATH));
1552 CopyGuid (&Vendor->Guid, &gEfiVT100PlusGuid);
1553
1554 return (EFI_DEVICE_PATH_PROTOCOL *) Vendor;
1555 }
1556
1557 /**
1558 Converts a text device path node to Vendor defined UTF8 device path structure.
1559
1560 @param TextDeviceNode The input Text device path node.
1561
1562 @return A pointer to the newly-created Vendor defined UTF8 device path structure.
1563
1564 **/
1565 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextVenUtf8(IN CHAR16 * TextDeviceNode)1566 DevPathFromTextVenUtf8 (
1567 IN CHAR16 *TextDeviceNode
1568 )
1569 {
1570 VENDOR_DEVICE_PATH *Vendor;
1571
1572 Vendor = (VENDOR_DEVICE_PATH *) CreateDeviceNode (
1573 MESSAGING_DEVICE_PATH,
1574 MSG_VENDOR_DP,
1575 (UINT16) sizeof (VENDOR_DEVICE_PATH));
1576 CopyGuid (&Vendor->Guid, &gEfiVTUTF8Guid);
1577
1578 return (EFI_DEVICE_PATH_PROTOCOL *) Vendor;
1579 }
1580
1581 /**
1582 Converts a text device path node to UART Flow Control device path structure.
1583
1584 @param TextDeviceNode The input Text device path node.
1585
1586 @return A pointer to the newly-created UART Flow Control device path structure.
1587
1588 **/
1589 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUartFlowCtrl(IN CHAR16 * TextDeviceNode)1590 DevPathFromTextUartFlowCtrl (
1591 IN CHAR16 *TextDeviceNode
1592 )
1593 {
1594 CHAR16 *ValueStr;
1595 UART_FLOW_CONTROL_DEVICE_PATH *UartFlowControl;
1596
1597 ValueStr = GetNextParamStr (&TextDeviceNode);
1598 UartFlowControl = (UART_FLOW_CONTROL_DEVICE_PATH *) CreateDeviceNode (
1599 MESSAGING_DEVICE_PATH,
1600 MSG_VENDOR_DP,
1601 (UINT16) sizeof (UART_FLOW_CONTROL_DEVICE_PATH)
1602 );
1603
1604 CopyGuid (&UartFlowControl->Guid, &gEfiUartDevicePathGuid);
1605 if (StrCmp (ValueStr, L"XonXoff") == 0) {
1606 UartFlowControl->FlowControlMap = 2;
1607 } else if (StrCmp (ValueStr, L"Hardware") == 0) {
1608 UartFlowControl->FlowControlMap = 1;
1609 } else {
1610 UartFlowControl->FlowControlMap = 0;
1611 }
1612
1613 return (EFI_DEVICE_PATH_PROTOCOL *) UartFlowControl;
1614 }
1615
1616 /**
1617 Converts a text device path node to Serial Attached SCSI device path structure.
1618
1619 @param TextDeviceNode The input Text device path node.
1620
1621 @return A pointer to the newly-created Serial Attached SCSI device path structure.
1622
1623 **/
1624 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextSAS(IN CHAR16 * TextDeviceNode)1625 DevPathFromTextSAS (
1626 IN CHAR16 *TextDeviceNode
1627 )
1628 {
1629 CHAR16 *AddressStr;
1630 CHAR16 *LunStr;
1631 CHAR16 *RTPStr;
1632 CHAR16 *SASSATAStr;
1633 CHAR16 *LocationStr;
1634 CHAR16 *ConnectStr;
1635 CHAR16 *DriveBayStr;
1636 CHAR16 *ReservedStr;
1637 UINT16 Info;
1638 UINT16 Uint16;
1639 SAS_DEVICE_PATH *Sas;
1640
1641 AddressStr = GetNextParamStr (&TextDeviceNode);
1642 LunStr = GetNextParamStr (&TextDeviceNode);
1643 RTPStr = GetNextParamStr (&TextDeviceNode);
1644 SASSATAStr = GetNextParamStr (&TextDeviceNode);
1645 LocationStr = GetNextParamStr (&TextDeviceNode);
1646 ConnectStr = GetNextParamStr (&TextDeviceNode);
1647 DriveBayStr = GetNextParamStr (&TextDeviceNode);
1648 ReservedStr = GetNextParamStr (&TextDeviceNode);
1649 Sas = (SAS_DEVICE_PATH *) CreateDeviceNode (
1650 MESSAGING_DEVICE_PATH,
1651 MSG_VENDOR_DP,
1652 (UINT16) sizeof (SAS_DEVICE_PATH)
1653 );
1654
1655 CopyGuid (&Sas->Guid, &gEfiSasDevicePathGuid);
1656 Strtoi64 (AddressStr, &Sas->SasAddress);
1657 Strtoi64 (LunStr, &Sas->Lun);
1658 Sas->RelativeTargetPort = (UINT16) Strtoi (RTPStr);
1659
1660 if (StrCmp (SASSATAStr, L"NoTopology") == 0) {
1661 Info = 0x0;
1662
1663 } else if ((StrCmp (SASSATAStr, L"SATA") == 0) || (StrCmp (SASSATAStr, L"SAS") == 0)) {
1664
1665 Uint16 = (UINT16) Strtoi (DriveBayStr);
1666 if (Uint16 == 0) {
1667 Info = 0x1;
1668 } else {
1669 Info = (UINT16) (0x2 | ((Uint16 - 1) << 8));
1670 }
1671
1672 if (StrCmp (SASSATAStr, L"SATA") == 0) {
1673 Info |= BIT4;
1674 }
1675
1676 //
1677 // Location is an integer between 0 and 1 or else
1678 // the keyword Internal (0) or External (1).
1679 //
1680 if (StrCmp (LocationStr, L"External") == 0) {
1681 Uint16 = 1;
1682 } else if (StrCmp (LocationStr, L"Internal") == 0) {
1683 Uint16 = 0;
1684 } else {
1685 Uint16 = ((UINT16) Strtoi (LocationStr) & BIT0);
1686 }
1687 Info |= (Uint16 << 5);
1688
1689 //
1690 // Connect is an integer between 0 and 3 or else
1691 // the keyword Direct (0) or Expanded (1).
1692 //
1693 if (StrCmp (ConnectStr, L"Expanded") == 0) {
1694 Uint16 = 1;
1695 } else if (StrCmp (ConnectStr, L"Direct") == 0) {
1696 Uint16 = 0;
1697 } else {
1698 Uint16 = ((UINT16) Strtoi (ConnectStr) & (BIT0 | BIT1));
1699 }
1700 Info |= (Uint16 << 6);
1701
1702 } else {
1703 Info = (UINT16) Strtoi (SASSATAStr);
1704 }
1705
1706 Sas->DeviceTopology = Info;
1707 Sas->Reserved = (UINT32) Strtoi (ReservedStr);
1708
1709 return (EFI_DEVICE_PATH_PROTOCOL *) Sas;
1710 }
1711
1712 /**
1713 Converts a text device path node to Serial Attached SCSI Ex device path structure.
1714
1715 @param TextDeviceNode The input Text device path node.
1716
1717 @return A pointer to the newly-created Serial Attached SCSI Ex device path structure.
1718
1719 **/
1720 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextSasEx(IN CHAR16 * TextDeviceNode)1721 DevPathFromTextSasEx (
1722 IN CHAR16 *TextDeviceNode
1723 )
1724 {
1725 CHAR16 *AddressStr;
1726 CHAR16 *LunStr;
1727 CHAR16 *RTPStr;
1728 CHAR16 *SASSATAStr;
1729 CHAR16 *LocationStr;
1730 CHAR16 *ConnectStr;
1731 CHAR16 *DriveBayStr;
1732 UINT16 Info;
1733 UINT16 Uint16;
1734 UINT64 SasAddress;
1735 UINT64 Lun;
1736 SASEX_DEVICE_PATH *SasEx;
1737
1738 AddressStr = GetNextParamStr (&TextDeviceNode);
1739 LunStr = GetNextParamStr (&TextDeviceNode);
1740 RTPStr = GetNextParamStr (&TextDeviceNode);
1741 SASSATAStr = GetNextParamStr (&TextDeviceNode);
1742 LocationStr = GetNextParamStr (&TextDeviceNode);
1743 ConnectStr = GetNextParamStr (&TextDeviceNode);
1744 DriveBayStr = GetNextParamStr (&TextDeviceNode);
1745 SasEx = (SASEX_DEVICE_PATH *) CreateDeviceNode (
1746 MESSAGING_DEVICE_PATH,
1747 MSG_SASEX_DP,
1748 (UINT16) sizeof (SASEX_DEVICE_PATH)
1749 );
1750
1751 Strtoi64 (AddressStr, &SasAddress);
1752 Strtoi64 (LunStr, &Lun);
1753 WriteUnaligned64 ((UINT64 *) &SasEx->SasAddress, SwapBytes64 (SasAddress));
1754 WriteUnaligned64 ((UINT64 *) &SasEx->Lun, SwapBytes64 (Lun));
1755 SasEx->RelativeTargetPort = (UINT16) Strtoi (RTPStr);
1756
1757 if (StrCmp (SASSATAStr, L"NoTopology") == 0) {
1758 Info = 0x0;
1759
1760 } else if ((StrCmp (SASSATAStr, L"SATA") == 0) || (StrCmp (SASSATAStr, L"SAS") == 0)) {
1761
1762 Uint16 = (UINT16) Strtoi (DriveBayStr);
1763 if (Uint16 == 0) {
1764 Info = 0x1;
1765 } else {
1766 Info = (UINT16) (0x2 | ((Uint16 - 1) << 8));
1767 }
1768
1769 if (StrCmp (SASSATAStr, L"SATA") == 0) {
1770 Info |= BIT4;
1771 }
1772
1773 //
1774 // Location is an integer between 0 and 1 or else
1775 // the keyword Internal (0) or External (1).
1776 //
1777 if (StrCmp (LocationStr, L"External") == 0) {
1778 Uint16 = 1;
1779 } else if (StrCmp (LocationStr, L"Internal") == 0) {
1780 Uint16 = 0;
1781 } else {
1782 Uint16 = ((UINT16) Strtoi (LocationStr) & BIT0);
1783 }
1784 Info |= (Uint16 << 5);
1785
1786 //
1787 // Connect is an integer between 0 and 3 or else
1788 // the keyword Direct (0) or Expanded (1).
1789 //
1790 if (StrCmp (ConnectStr, L"Expanded") == 0) {
1791 Uint16 = 1;
1792 } else if (StrCmp (ConnectStr, L"Direct") == 0) {
1793 Uint16 = 0;
1794 } else {
1795 Uint16 = ((UINT16) Strtoi (ConnectStr) & (BIT0 | BIT1));
1796 }
1797 Info |= (Uint16 << 6);
1798
1799 } else {
1800 Info = (UINT16) Strtoi (SASSATAStr);
1801 }
1802
1803 SasEx->DeviceTopology = Info;
1804
1805 return (EFI_DEVICE_PATH_PROTOCOL *) SasEx;
1806 }
1807
1808 /**
1809 Converts a text device path node to NVM Express Namespace device path structure.
1810
1811 @param TextDeviceNode The input Text device path node.
1812
1813 @return A pointer to the newly-created NVM Express Namespace device path structure.
1814
1815 **/
1816 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextNVMe(IN CHAR16 * TextDeviceNode)1817 DevPathFromTextNVMe (
1818 IN CHAR16 *TextDeviceNode
1819 )
1820 {
1821 CHAR16 *NamespaceIdStr;
1822 CHAR16 *NamespaceUuidStr;
1823 NVME_NAMESPACE_DEVICE_PATH *Nvme;
1824 UINT8 *Uuid;
1825 UINTN Index;
1826
1827 NamespaceIdStr = GetNextParamStr (&TextDeviceNode);
1828 NamespaceUuidStr = GetNextParamStr (&TextDeviceNode);
1829 Nvme = (NVME_NAMESPACE_DEVICE_PATH *) CreateDeviceNode (
1830 MESSAGING_DEVICE_PATH,
1831 MSG_NVME_NAMESPACE_DP,
1832 (UINT16) sizeof (NVME_NAMESPACE_DEVICE_PATH)
1833 );
1834
1835 Nvme->NamespaceId = (UINT32) Strtoi (NamespaceIdStr);
1836 Uuid = (UINT8 *) &Nvme->NamespaceUuid;
1837
1838 Index = sizeof (Nvme->NamespaceUuid) / sizeof (UINT8);
1839 while (Index-- != 0) {
1840 Uuid[Index] = (UINT8) StrHexToUintn (SplitStr (&NamespaceUuidStr, L'-'));
1841 }
1842
1843 return (EFI_DEVICE_PATH_PROTOCOL *) Nvme;
1844 }
1845
1846 /**
1847 Converts a text device path node to UFS device path structure.
1848
1849 @param TextDeviceNode The input Text device path node.
1850
1851 @return A pointer to the newly-created UFS device path structure.
1852
1853 **/
1854 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUfs(IN CHAR16 * TextDeviceNode)1855 DevPathFromTextUfs (
1856 IN CHAR16 *TextDeviceNode
1857 )
1858 {
1859 CHAR16 *PunStr;
1860 CHAR16 *LunStr;
1861 UFS_DEVICE_PATH *Ufs;
1862
1863 PunStr = GetNextParamStr (&TextDeviceNode);
1864 LunStr = GetNextParamStr (&TextDeviceNode);
1865 Ufs = (UFS_DEVICE_PATH *) CreateDeviceNode (
1866 MESSAGING_DEVICE_PATH,
1867 MSG_UFS_DP,
1868 (UINT16) sizeof (UFS_DEVICE_PATH)
1869 );
1870
1871 Ufs->Pun = (UINT8) Strtoi (PunStr);
1872 Ufs->Lun = (UINT8) Strtoi (LunStr);
1873
1874 return (EFI_DEVICE_PATH_PROTOCOL *) Ufs;
1875 }
1876
1877 /**
1878 Converts a text device path node to SD (Secure Digital) device path structure.
1879
1880 @param TextDeviceNode The input Text device path node.
1881
1882 @return A pointer to the newly-created SD device path structure.
1883
1884 **/
1885 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextSd(IN CHAR16 * TextDeviceNode)1886 DevPathFromTextSd (
1887 IN CHAR16 *TextDeviceNode
1888 )
1889 {
1890 CHAR16 *SlotNumberStr;
1891 SD_DEVICE_PATH *Sd;
1892
1893 SlotNumberStr = GetNextParamStr (&TextDeviceNode);
1894 Sd = (SD_DEVICE_PATH *) CreateDeviceNode (
1895 MESSAGING_DEVICE_PATH,
1896 MSG_SD_DP,
1897 (UINT16) sizeof (SD_DEVICE_PATH)
1898 );
1899
1900 Sd->SlotNumber = (UINT8) Strtoi (SlotNumberStr);
1901
1902 return (EFI_DEVICE_PATH_PROTOCOL *) Sd;
1903 }
1904
1905 /**
1906 Converts a text device path node to Debug Port device path structure.
1907
1908 @param TextDeviceNode The input Text device path node.
1909
1910 @return A pointer to the newly-created Debug Port device path structure.
1911
1912 **/
1913 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextDebugPort(IN CHAR16 * TextDeviceNode)1914 DevPathFromTextDebugPort (
1915 IN CHAR16 *TextDeviceNode
1916 )
1917 {
1918 VENDOR_DEFINED_MESSAGING_DEVICE_PATH *Vend;
1919
1920 Vend = (VENDOR_DEFINED_MESSAGING_DEVICE_PATH *) CreateDeviceNode (
1921 MESSAGING_DEVICE_PATH,
1922 MSG_VENDOR_DP,
1923 (UINT16) sizeof (VENDOR_DEFINED_MESSAGING_DEVICE_PATH)
1924 );
1925
1926 CopyGuid (&Vend->Guid, &gEfiDebugPortProtocolGuid);
1927
1928 return (EFI_DEVICE_PATH_PROTOCOL *) Vend;
1929 }
1930
1931 /**
1932 Converts a text device path node to MAC device path structure.
1933
1934 @param TextDeviceNode The input Text device path node.
1935
1936 @return A pointer to the newly-created MAC device path structure.
1937
1938 **/
1939 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextMAC(IN CHAR16 * TextDeviceNode)1940 DevPathFromTextMAC (
1941 IN CHAR16 *TextDeviceNode
1942 )
1943 {
1944 CHAR16 *AddressStr;
1945 CHAR16 *IfTypeStr;
1946 UINTN Length;
1947 MAC_ADDR_DEVICE_PATH *MACDevPath;
1948
1949 AddressStr = GetNextParamStr (&TextDeviceNode);
1950 IfTypeStr = GetNextParamStr (&TextDeviceNode);
1951 MACDevPath = (MAC_ADDR_DEVICE_PATH *) CreateDeviceNode (
1952 MESSAGING_DEVICE_PATH,
1953 MSG_MAC_ADDR_DP,
1954 (UINT16) sizeof (MAC_ADDR_DEVICE_PATH)
1955 );
1956
1957 MACDevPath->IfType = (UINT8) Strtoi (IfTypeStr);
1958
1959 Length = sizeof (EFI_MAC_ADDRESS);
1960 StrToBuf (&MACDevPath->MacAddress.Addr[0], Length, AddressStr);
1961
1962 return (EFI_DEVICE_PATH_PROTOCOL *) MACDevPath;
1963 }
1964
1965
1966 /**
1967 Converts a text format to the network protocol ID.
1968
1969 @param Text String of protocol field.
1970
1971 @return Network protocol ID .
1972
1973 **/
1974 UINTN
NetworkProtocolFromText(IN CHAR16 * Text)1975 NetworkProtocolFromText (
1976 IN CHAR16 *Text
1977 )
1978 {
1979 if (StrCmp (Text, L"UDP") == 0) {
1980 return RFC_1700_UDP_PROTOCOL;
1981 }
1982
1983 if (StrCmp (Text, L"TCP") == 0) {
1984 return RFC_1700_TCP_PROTOCOL;
1985 }
1986
1987 return Strtoi (Text);
1988 }
1989
1990
1991 /**
1992 Converts a text device path node to IPV4 device path structure.
1993
1994 @param TextDeviceNode The input Text device path node.
1995
1996 @return A pointer to the newly-created IPV4 device path structure.
1997
1998 **/
1999 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextIPv4(IN CHAR16 * TextDeviceNode)2000 DevPathFromTextIPv4 (
2001 IN CHAR16 *TextDeviceNode
2002 )
2003 {
2004 CHAR16 *RemoteIPStr;
2005 CHAR16 *ProtocolStr;
2006 CHAR16 *TypeStr;
2007 CHAR16 *LocalIPStr;
2008 CHAR16 *GatewayIPStr;
2009 CHAR16 *SubnetMaskStr;
2010 IPv4_DEVICE_PATH *IPv4;
2011
2012 RemoteIPStr = GetNextParamStr (&TextDeviceNode);
2013 ProtocolStr = GetNextParamStr (&TextDeviceNode);
2014 TypeStr = GetNextParamStr (&TextDeviceNode);
2015 LocalIPStr = GetNextParamStr (&TextDeviceNode);
2016 GatewayIPStr = GetNextParamStr (&TextDeviceNode);
2017 SubnetMaskStr = GetNextParamStr (&TextDeviceNode);
2018 IPv4 = (IPv4_DEVICE_PATH *) CreateDeviceNode (
2019 MESSAGING_DEVICE_PATH,
2020 MSG_IPv4_DP,
2021 (UINT16) sizeof (IPv4_DEVICE_PATH)
2022 );
2023
2024 StrToIPv4Addr (&RemoteIPStr, &IPv4->RemoteIpAddress);
2025 IPv4->Protocol = (UINT16) NetworkProtocolFromText (ProtocolStr);
2026 if (StrCmp (TypeStr, L"Static") == 0) {
2027 IPv4->StaticIpAddress = TRUE;
2028 } else {
2029 IPv4->StaticIpAddress = FALSE;
2030 }
2031
2032 StrToIPv4Addr (&LocalIPStr, &IPv4->LocalIpAddress);
2033 if (!IS_NULL (*GatewayIPStr) && !IS_NULL (*SubnetMaskStr)) {
2034 StrToIPv4Addr (&GatewayIPStr, &IPv4->GatewayIpAddress);
2035 StrToIPv4Addr (&SubnetMaskStr, &IPv4->SubnetMask);
2036 } else {
2037 ZeroMem (&IPv4->GatewayIpAddress, sizeof (IPv4->GatewayIpAddress));
2038 ZeroMem (&IPv4->SubnetMask, sizeof (IPv4->SubnetMask));
2039 }
2040
2041 IPv4->LocalPort = 0;
2042 IPv4->RemotePort = 0;
2043
2044 return (EFI_DEVICE_PATH_PROTOCOL *) IPv4;
2045 }
2046
2047 /**
2048 Converts a text device path node to IPV6 device path structure.
2049
2050 @param TextDeviceNode The input Text device path node.
2051
2052 @return A pointer to the newly-created IPV6 device path structure.
2053
2054 **/
2055 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextIPv6(IN CHAR16 * TextDeviceNode)2056 DevPathFromTextIPv6 (
2057 IN CHAR16 *TextDeviceNode
2058 )
2059 {
2060 CHAR16 *RemoteIPStr;
2061 CHAR16 *ProtocolStr;
2062 CHAR16 *TypeStr;
2063 CHAR16 *LocalIPStr;
2064 CHAR16 *GatewayIPStr;
2065 CHAR16 *PrefixLengthStr;
2066 IPv6_DEVICE_PATH *IPv6;
2067
2068 RemoteIPStr = GetNextParamStr (&TextDeviceNode);
2069 ProtocolStr = GetNextParamStr (&TextDeviceNode);
2070 TypeStr = GetNextParamStr (&TextDeviceNode);
2071 LocalIPStr = GetNextParamStr (&TextDeviceNode);
2072 PrefixLengthStr = GetNextParamStr (&TextDeviceNode);
2073 GatewayIPStr = GetNextParamStr (&TextDeviceNode);
2074 IPv6 = (IPv6_DEVICE_PATH *) CreateDeviceNode (
2075 MESSAGING_DEVICE_PATH,
2076 MSG_IPv6_DP,
2077 (UINT16) sizeof (IPv6_DEVICE_PATH)
2078 );
2079
2080 StrToIPv6Addr (&RemoteIPStr, &IPv6->RemoteIpAddress);
2081 IPv6->Protocol = (UINT16) NetworkProtocolFromText (ProtocolStr);
2082 if (StrCmp (TypeStr, L"Static") == 0) {
2083 IPv6->IpAddressOrigin = 0;
2084 } else if (StrCmp (TypeStr, L"StatelessAutoConfigure") == 0) {
2085 IPv6->IpAddressOrigin = 1;
2086 } else {
2087 IPv6->IpAddressOrigin = 2;
2088 }
2089
2090 StrToIPv6Addr (&LocalIPStr, &IPv6->LocalIpAddress);
2091 if (!IS_NULL (*GatewayIPStr) && !IS_NULL (*PrefixLengthStr)) {
2092 StrToIPv6Addr (&GatewayIPStr, &IPv6->GatewayIpAddress);
2093 IPv6->PrefixLength = (UINT8) Strtoi (PrefixLengthStr);
2094 } else {
2095 ZeroMem (&IPv6->GatewayIpAddress, sizeof (IPv6->GatewayIpAddress));
2096 IPv6->PrefixLength = 0;
2097 }
2098
2099 IPv6->LocalPort = 0;
2100 IPv6->RemotePort = 0;
2101
2102 return (EFI_DEVICE_PATH_PROTOCOL *) IPv6;
2103 }
2104
2105 /**
2106 Converts a text device path node to UART device path structure.
2107
2108 @param TextDeviceNode The input Text device path node.
2109
2110 @return A pointer to the newly-created UART device path structure.
2111
2112 **/
2113 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUart(IN CHAR16 * TextDeviceNode)2114 DevPathFromTextUart (
2115 IN CHAR16 *TextDeviceNode
2116 )
2117 {
2118 CHAR16 *BaudStr;
2119 CHAR16 *DataBitsStr;
2120 CHAR16 *ParityStr;
2121 CHAR16 *StopBitsStr;
2122 UART_DEVICE_PATH *Uart;
2123
2124 BaudStr = GetNextParamStr (&TextDeviceNode);
2125 DataBitsStr = GetNextParamStr (&TextDeviceNode);
2126 ParityStr = GetNextParamStr (&TextDeviceNode);
2127 StopBitsStr = GetNextParamStr (&TextDeviceNode);
2128 Uart = (UART_DEVICE_PATH *) CreateDeviceNode (
2129 MESSAGING_DEVICE_PATH,
2130 MSG_UART_DP,
2131 (UINT16) sizeof (UART_DEVICE_PATH)
2132 );
2133
2134 if (StrCmp (BaudStr, L"DEFAULT") == 0) {
2135 Uart->BaudRate = 115200;
2136 } else {
2137 Strtoi64 (BaudStr, &Uart->BaudRate);
2138 }
2139 Uart->DataBits = (UINT8) ((StrCmp (DataBitsStr, L"DEFAULT") == 0) ? 8 : Strtoi (DataBitsStr));
2140 switch (*ParityStr) {
2141 case L'D':
2142 Uart->Parity = 0;
2143 break;
2144
2145 case L'N':
2146 Uart->Parity = 1;
2147 break;
2148
2149 case L'E':
2150 Uart->Parity = 2;
2151 break;
2152
2153 case L'O':
2154 Uart->Parity = 3;
2155 break;
2156
2157 case L'M':
2158 Uart->Parity = 4;
2159 break;
2160
2161 case L'S':
2162 Uart->Parity = 5;
2163 break;
2164
2165 default:
2166 Uart->Parity = (UINT8) Strtoi (ParityStr);
2167 break;
2168 }
2169
2170 if (StrCmp (StopBitsStr, L"D") == 0) {
2171 Uart->StopBits = (UINT8) 0;
2172 } else if (StrCmp (StopBitsStr, L"1") == 0) {
2173 Uart->StopBits = (UINT8) 1;
2174 } else if (StrCmp (StopBitsStr, L"1.5") == 0) {
2175 Uart->StopBits = (UINT8) 2;
2176 } else if (StrCmp (StopBitsStr, L"2") == 0) {
2177 Uart->StopBits = (UINT8) 3;
2178 } else {
2179 Uart->StopBits = (UINT8) Strtoi (StopBitsStr);
2180 }
2181
2182 return (EFI_DEVICE_PATH_PROTOCOL *) Uart;
2183 }
2184
2185 /**
2186 Converts a text device path node to USB class device path structure.
2187
2188 @param TextDeviceNode The input Text device path node.
2189 @param UsbClassText A pointer to USB_CLASS_TEXT structure to be integrated to USB Class Text.
2190
2191 @return A pointer to the newly-created USB class device path structure.
2192
2193 **/
2194 EFI_DEVICE_PATH_PROTOCOL *
ConvertFromTextUsbClass(IN CHAR16 * TextDeviceNode,IN USB_CLASS_TEXT * UsbClassText)2195 ConvertFromTextUsbClass (
2196 IN CHAR16 *TextDeviceNode,
2197 IN USB_CLASS_TEXT *UsbClassText
2198 )
2199 {
2200 CHAR16 *VIDStr;
2201 CHAR16 *PIDStr;
2202 CHAR16 *ClassStr;
2203 CHAR16 *SubClassStr;
2204 CHAR16 *ProtocolStr;
2205 USB_CLASS_DEVICE_PATH *UsbClass;
2206
2207 UsbClass = (USB_CLASS_DEVICE_PATH *) CreateDeviceNode (
2208 MESSAGING_DEVICE_PATH,
2209 MSG_USB_CLASS_DP,
2210 (UINT16) sizeof (USB_CLASS_DEVICE_PATH)
2211 );
2212
2213 VIDStr = GetNextParamStr (&TextDeviceNode);
2214 PIDStr = GetNextParamStr (&TextDeviceNode);
2215 if (UsbClassText->ClassExist) {
2216 ClassStr = GetNextParamStr (&TextDeviceNode);
2217 UsbClass->DeviceClass = (UINT8) Strtoi (ClassStr);
2218 } else {
2219 UsbClass->DeviceClass = UsbClassText->Class;
2220 }
2221 if (UsbClassText->SubClassExist) {
2222 SubClassStr = GetNextParamStr (&TextDeviceNode);
2223 UsbClass->DeviceSubClass = (UINT8) Strtoi (SubClassStr);
2224 } else {
2225 UsbClass->DeviceSubClass = UsbClassText->SubClass;
2226 }
2227
2228 ProtocolStr = GetNextParamStr (&TextDeviceNode);
2229
2230 UsbClass->VendorId = (UINT16) Strtoi (VIDStr);
2231 UsbClass->ProductId = (UINT16) Strtoi (PIDStr);
2232 UsbClass->DeviceProtocol = (UINT8) Strtoi (ProtocolStr);
2233
2234 return (EFI_DEVICE_PATH_PROTOCOL *) UsbClass;
2235 }
2236
2237
2238 /**
2239 Converts a text device path node to USB class device path structure.
2240
2241 @param TextDeviceNode The input Text device path node.
2242
2243 @return A pointer to the newly-created USB class device path structure.
2244
2245 **/
2246 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbClass(IN CHAR16 * TextDeviceNode)2247 DevPathFromTextUsbClass (
2248 IN CHAR16 *TextDeviceNode
2249 )
2250 {
2251 USB_CLASS_TEXT UsbClassText;
2252
2253 UsbClassText.ClassExist = TRUE;
2254 UsbClassText.SubClassExist = TRUE;
2255
2256 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2257 }
2258
2259 /**
2260 Converts a text device path node to USB audio device path structure.
2261
2262 @param TextDeviceNode The input Text device path node.
2263
2264 @return A pointer to the newly-created USB audio device path structure.
2265
2266 **/
2267 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbAudio(IN CHAR16 * TextDeviceNode)2268 DevPathFromTextUsbAudio (
2269 IN CHAR16 *TextDeviceNode
2270 )
2271 {
2272 USB_CLASS_TEXT UsbClassText;
2273
2274 UsbClassText.ClassExist = FALSE;
2275 UsbClassText.Class = USB_CLASS_AUDIO;
2276 UsbClassText.SubClassExist = TRUE;
2277
2278 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2279 }
2280
2281 /**
2282 Converts a text device path node to USB CDC Control device path structure.
2283
2284 @param TextDeviceNode The input Text device path node.
2285
2286 @return A pointer to the newly-created USB CDC Control device path structure.
2287
2288 **/
2289 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbCDCControl(IN CHAR16 * TextDeviceNode)2290 DevPathFromTextUsbCDCControl (
2291 IN CHAR16 *TextDeviceNode
2292 )
2293 {
2294 USB_CLASS_TEXT UsbClassText;
2295
2296 UsbClassText.ClassExist = FALSE;
2297 UsbClassText.Class = USB_CLASS_CDCCONTROL;
2298 UsbClassText.SubClassExist = TRUE;
2299
2300 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2301 }
2302
2303 /**
2304 Converts a text device path node to USB HID device path structure.
2305
2306 @param TextDeviceNode The input Text device path node.
2307
2308 @return A pointer to the newly-created USB HID device path structure.
2309
2310 **/
2311 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbHID(IN CHAR16 * TextDeviceNode)2312 DevPathFromTextUsbHID (
2313 IN CHAR16 *TextDeviceNode
2314 )
2315 {
2316 USB_CLASS_TEXT UsbClassText;
2317
2318 UsbClassText.ClassExist = FALSE;
2319 UsbClassText.Class = USB_CLASS_HID;
2320 UsbClassText.SubClassExist = TRUE;
2321
2322 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2323 }
2324
2325 /**
2326 Converts a text device path node to USB Image device path structure.
2327
2328 @param TextDeviceNode The input Text device path node.
2329
2330 @return A pointer to the newly-created USB Image device path structure.
2331
2332 **/
2333 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbImage(IN CHAR16 * TextDeviceNode)2334 DevPathFromTextUsbImage (
2335 IN CHAR16 *TextDeviceNode
2336 )
2337 {
2338 USB_CLASS_TEXT UsbClassText;
2339
2340 UsbClassText.ClassExist = FALSE;
2341 UsbClassText.Class = USB_CLASS_IMAGE;
2342 UsbClassText.SubClassExist = TRUE;
2343
2344 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2345 }
2346
2347 /**
2348 Converts a text device path node to USB Print device path structure.
2349
2350 @param TextDeviceNode The input Text device path node.
2351
2352 @return A pointer to the newly-created USB Print device path structure.
2353
2354 **/
2355 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbPrinter(IN CHAR16 * TextDeviceNode)2356 DevPathFromTextUsbPrinter (
2357 IN CHAR16 *TextDeviceNode
2358 )
2359 {
2360 USB_CLASS_TEXT UsbClassText;
2361
2362 UsbClassText.ClassExist = FALSE;
2363 UsbClassText.Class = USB_CLASS_PRINTER;
2364 UsbClassText.SubClassExist = TRUE;
2365
2366 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2367 }
2368
2369 /**
2370 Converts a text device path node to USB mass storage device path structure.
2371
2372 @param TextDeviceNode The input Text device path node.
2373
2374 @return A pointer to the newly-created USB mass storage device path structure.
2375
2376 **/
2377 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbMassStorage(IN CHAR16 * TextDeviceNode)2378 DevPathFromTextUsbMassStorage (
2379 IN CHAR16 *TextDeviceNode
2380 )
2381 {
2382 USB_CLASS_TEXT UsbClassText;
2383
2384 UsbClassText.ClassExist = FALSE;
2385 UsbClassText.Class = USB_CLASS_MASS_STORAGE;
2386 UsbClassText.SubClassExist = TRUE;
2387
2388 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2389 }
2390
2391 /**
2392 Converts a text device path node to USB HUB device path structure.
2393
2394 @param TextDeviceNode The input Text device path node.
2395
2396 @return A pointer to the newly-created USB HUB device path structure.
2397
2398 **/
2399 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbHub(IN CHAR16 * TextDeviceNode)2400 DevPathFromTextUsbHub (
2401 IN CHAR16 *TextDeviceNode
2402 )
2403 {
2404 USB_CLASS_TEXT UsbClassText;
2405
2406 UsbClassText.ClassExist = FALSE;
2407 UsbClassText.Class = USB_CLASS_HUB;
2408 UsbClassText.SubClassExist = TRUE;
2409
2410 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2411 }
2412
2413 /**
2414 Converts a text device path node to USB CDC data device path structure.
2415
2416 @param TextDeviceNode The input Text device path node.
2417
2418 @return A pointer to the newly-created USB CDC data device path structure.
2419
2420 **/
2421 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbCDCData(IN CHAR16 * TextDeviceNode)2422 DevPathFromTextUsbCDCData (
2423 IN CHAR16 *TextDeviceNode
2424 )
2425 {
2426 USB_CLASS_TEXT UsbClassText;
2427
2428 UsbClassText.ClassExist = FALSE;
2429 UsbClassText.Class = USB_CLASS_CDCDATA;
2430 UsbClassText.SubClassExist = TRUE;
2431
2432 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2433 }
2434
2435 /**
2436 Converts a text device path node to USB smart card device path structure.
2437
2438 @param TextDeviceNode The input Text device path node.
2439
2440 @return A pointer to the newly-created USB smart card device path structure.
2441
2442 **/
2443 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbSmartCard(IN CHAR16 * TextDeviceNode)2444 DevPathFromTextUsbSmartCard (
2445 IN CHAR16 *TextDeviceNode
2446 )
2447 {
2448 USB_CLASS_TEXT UsbClassText;
2449
2450 UsbClassText.ClassExist = FALSE;
2451 UsbClassText.Class = USB_CLASS_SMART_CARD;
2452 UsbClassText.SubClassExist = TRUE;
2453
2454 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2455 }
2456
2457 /**
2458 Converts a text device path node to USB video device path structure.
2459
2460 @param TextDeviceNode The input Text device path node.
2461
2462 @return A pointer to the newly-created USB video device path structure.
2463
2464 **/
2465 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbVideo(IN CHAR16 * TextDeviceNode)2466 DevPathFromTextUsbVideo (
2467 IN CHAR16 *TextDeviceNode
2468 )
2469 {
2470 USB_CLASS_TEXT UsbClassText;
2471
2472 UsbClassText.ClassExist = FALSE;
2473 UsbClassText.Class = USB_CLASS_VIDEO;
2474 UsbClassText.SubClassExist = TRUE;
2475
2476 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2477 }
2478
2479 /**
2480 Converts a text device path node to USB diagnostic device path structure.
2481
2482 @param TextDeviceNode The input Text device path node.
2483
2484 @return A pointer to the newly-created USB diagnostic device path structure.
2485
2486 **/
2487 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbDiagnostic(IN CHAR16 * TextDeviceNode)2488 DevPathFromTextUsbDiagnostic (
2489 IN CHAR16 *TextDeviceNode
2490 )
2491 {
2492 USB_CLASS_TEXT UsbClassText;
2493
2494 UsbClassText.ClassExist = FALSE;
2495 UsbClassText.Class = USB_CLASS_DIAGNOSTIC;
2496 UsbClassText.SubClassExist = TRUE;
2497
2498 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2499 }
2500
2501 /**
2502 Converts a text device path node to USB wireless device path structure.
2503
2504 @param TextDeviceNode The input Text device path node.
2505
2506 @return A pointer to the newly-created USB wireless device path structure.
2507
2508 **/
2509 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbWireless(IN CHAR16 * TextDeviceNode)2510 DevPathFromTextUsbWireless (
2511 IN CHAR16 *TextDeviceNode
2512 )
2513 {
2514 USB_CLASS_TEXT UsbClassText;
2515
2516 UsbClassText.ClassExist = FALSE;
2517 UsbClassText.Class = USB_CLASS_WIRELESS;
2518 UsbClassText.SubClassExist = TRUE;
2519
2520 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2521 }
2522
2523 /**
2524 Converts a text device path node to USB device firmware update device path structure.
2525
2526 @param TextDeviceNode The input Text device path node.
2527
2528 @return A pointer to the newly-created USB device firmware update device path structure.
2529
2530 **/
2531 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbDeviceFirmwareUpdate(IN CHAR16 * TextDeviceNode)2532 DevPathFromTextUsbDeviceFirmwareUpdate (
2533 IN CHAR16 *TextDeviceNode
2534 )
2535 {
2536 USB_CLASS_TEXT UsbClassText;
2537
2538 UsbClassText.ClassExist = FALSE;
2539 UsbClassText.Class = USB_CLASS_RESERVE;
2540 UsbClassText.SubClassExist = FALSE;
2541 UsbClassText.SubClass = USB_SUBCLASS_FW_UPDATE;
2542
2543 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2544 }
2545
2546 /**
2547 Converts a text device path node to USB IRDA bridge device path structure.
2548
2549 @param TextDeviceNode The input Text device path node.
2550
2551 @return A pointer to the newly-created USB IRDA bridge device path structure.
2552
2553 **/
2554 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbIrdaBridge(IN CHAR16 * TextDeviceNode)2555 DevPathFromTextUsbIrdaBridge (
2556 IN CHAR16 *TextDeviceNode
2557 )
2558 {
2559 USB_CLASS_TEXT UsbClassText;
2560
2561 UsbClassText.ClassExist = FALSE;
2562 UsbClassText.Class = USB_CLASS_RESERVE;
2563 UsbClassText.SubClassExist = FALSE;
2564 UsbClassText.SubClass = USB_SUBCLASS_IRDA_BRIDGE;
2565
2566 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2567 }
2568
2569 /**
2570 Converts a text device path node to USB text and measurement device path structure.
2571
2572 @param TextDeviceNode The input Text device path node.
2573
2574 @return A pointer to the newly-created USB text and measurement device path structure.
2575
2576 **/
2577 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbTestAndMeasurement(IN CHAR16 * TextDeviceNode)2578 DevPathFromTextUsbTestAndMeasurement (
2579 IN CHAR16 *TextDeviceNode
2580 )
2581 {
2582 USB_CLASS_TEXT UsbClassText;
2583
2584 UsbClassText.ClassExist = FALSE;
2585 UsbClassText.Class = USB_CLASS_RESERVE;
2586 UsbClassText.SubClassExist = FALSE;
2587 UsbClassText.SubClass = USB_SUBCLASS_TEST;
2588
2589 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2590 }
2591
2592 /**
2593 Converts a text device path node to USB WWID device path structure.
2594
2595 @param TextDeviceNode The input Text device path node.
2596
2597 @return A pointer to the newly-created USB WWID device path structure.
2598
2599 **/
2600 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbWwid(IN CHAR16 * TextDeviceNode)2601 DevPathFromTextUsbWwid (
2602 IN CHAR16 *TextDeviceNode
2603 )
2604 {
2605 CHAR16 *VIDStr;
2606 CHAR16 *PIDStr;
2607 CHAR16 *InterfaceNumStr;
2608 CHAR16 *SerialNumberStr;
2609 USB_WWID_DEVICE_PATH *UsbWwid;
2610 UINTN SerialNumberStrLen;
2611
2612 VIDStr = GetNextParamStr (&TextDeviceNode);
2613 PIDStr = GetNextParamStr (&TextDeviceNode);
2614 InterfaceNumStr = GetNextParamStr (&TextDeviceNode);
2615 SerialNumberStr = GetNextParamStr (&TextDeviceNode);
2616 SerialNumberStrLen = StrLen (SerialNumberStr);
2617 if (SerialNumberStrLen >= 2 &&
2618 SerialNumberStr[0] == L'\"' &&
2619 SerialNumberStr[SerialNumberStrLen - 1] == L'\"'
2620 ) {
2621 SerialNumberStr[SerialNumberStrLen - 1] = L'\0';
2622 SerialNumberStr++;
2623 SerialNumberStrLen -= 2;
2624 }
2625 UsbWwid = (USB_WWID_DEVICE_PATH *) CreateDeviceNode (
2626 MESSAGING_DEVICE_PATH,
2627 MSG_USB_WWID_DP,
2628 (UINT16) (sizeof (USB_WWID_DEVICE_PATH) + SerialNumberStrLen * sizeof (CHAR16))
2629 );
2630 UsbWwid->VendorId = (UINT16) Strtoi (VIDStr);
2631 UsbWwid->ProductId = (UINT16) Strtoi (PIDStr);
2632 UsbWwid->InterfaceNumber = (UINT16) Strtoi (InterfaceNumStr);
2633
2634 //
2635 // There is no memory allocated in UsbWwid for the '\0' in SerialNumberStr.
2636 // Therefore, the '\0' will not be copied.
2637 //
2638 CopyMem (
2639 (UINT8 *) UsbWwid + sizeof (USB_WWID_DEVICE_PATH),
2640 SerialNumberStr,
2641 SerialNumberStrLen * sizeof (CHAR16)
2642 );
2643
2644 return (EFI_DEVICE_PATH_PROTOCOL *) UsbWwid;
2645 }
2646
2647 /**
2648 Converts a text device path node to Logic Unit device path structure.
2649
2650 @param TextDeviceNode The input Text device path node.
2651
2652 @return A pointer to the newly-created Logic Unit device path structure.
2653
2654 **/
2655 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUnit(IN CHAR16 * TextDeviceNode)2656 DevPathFromTextUnit (
2657 IN CHAR16 *TextDeviceNode
2658 )
2659 {
2660 CHAR16 *LunStr;
2661 DEVICE_LOGICAL_UNIT_DEVICE_PATH *LogicalUnit;
2662
2663 LunStr = GetNextParamStr (&TextDeviceNode);
2664 LogicalUnit = (DEVICE_LOGICAL_UNIT_DEVICE_PATH *) CreateDeviceNode (
2665 MESSAGING_DEVICE_PATH,
2666 MSG_DEVICE_LOGICAL_UNIT_DP,
2667 (UINT16) sizeof (DEVICE_LOGICAL_UNIT_DEVICE_PATH)
2668 );
2669
2670 LogicalUnit->Lun = (UINT8) Strtoi (LunStr);
2671
2672 return (EFI_DEVICE_PATH_PROTOCOL *) LogicalUnit;
2673 }
2674
2675 /**
2676 Converts a text device path node to iSCSI device path structure.
2677
2678 @param TextDeviceNode The input Text device path node.
2679
2680 @return A pointer to the newly-created iSCSI device path structure.
2681
2682 **/
2683 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextiSCSI(IN CHAR16 * TextDeviceNode)2684 DevPathFromTextiSCSI (
2685 IN CHAR16 *TextDeviceNode
2686 )
2687 {
2688 UINT16 Options;
2689 CHAR16 *NameStr;
2690 CHAR16 *PortalGroupStr;
2691 CHAR16 *LunStr;
2692 CHAR16 *HeaderDigestStr;
2693 CHAR16 *DataDigestStr;
2694 CHAR16 *AuthenticationStr;
2695 CHAR16 *ProtocolStr;
2696 CHAR8 *AsciiStr;
2697 ISCSI_DEVICE_PATH_WITH_NAME *ISCSIDevPath;
2698
2699 NameStr = GetNextParamStr (&TextDeviceNode);
2700 PortalGroupStr = GetNextParamStr (&TextDeviceNode);
2701 LunStr = GetNextParamStr (&TextDeviceNode);
2702 HeaderDigestStr = GetNextParamStr (&TextDeviceNode);
2703 DataDigestStr = GetNextParamStr (&TextDeviceNode);
2704 AuthenticationStr = GetNextParamStr (&TextDeviceNode);
2705 ProtocolStr = GetNextParamStr (&TextDeviceNode);
2706 ISCSIDevPath = (ISCSI_DEVICE_PATH_WITH_NAME *) CreateDeviceNode (
2707 MESSAGING_DEVICE_PATH,
2708 MSG_ISCSI_DP,
2709 (UINT16) (sizeof (ISCSI_DEVICE_PATH_WITH_NAME) + StrLen (NameStr))
2710 );
2711
2712 AsciiStr = ISCSIDevPath->TargetName;
2713 StrToAscii (NameStr, &AsciiStr);
2714
2715 ISCSIDevPath->TargetPortalGroupTag = (UINT16) Strtoi (PortalGroupStr);
2716 Strtoi64 (LunStr, &ISCSIDevPath->Lun);
2717
2718 Options = 0x0000;
2719 if (StrCmp (HeaderDigestStr, L"CRC32C") == 0) {
2720 Options |= 0x0002;
2721 }
2722
2723 if (StrCmp (DataDigestStr, L"CRC32C") == 0) {
2724 Options |= 0x0008;
2725 }
2726
2727 if (StrCmp (AuthenticationStr, L"None") == 0) {
2728 Options |= 0x0800;
2729 }
2730
2731 if (StrCmp (AuthenticationStr, L"CHAP_UNI") == 0) {
2732 Options |= 0x1000;
2733 }
2734
2735 ISCSIDevPath->LoginOption = (UINT16) Options;
2736
2737 ISCSIDevPath->NetworkProtocol = (UINT16) StrCmp (ProtocolStr, L"TCP");
2738
2739 return (EFI_DEVICE_PATH_PROTOCOL *) ISCSIDevPath;
2740 }
2741
2742 /**
2743 Converts a text device path node to VLAN device path structure.
2744
2745 @param TextDeviceNode The input Text device path node.
2746
2747 @return A pointer to the newly-created VLAN device path structure.
2748
2749 **/
2750 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextVlan(IN CHAR16 * TextDeviceNode)2751 DevPathFromTextVlan (
2752 IN CHAR16 *TextDeviceNode
2753 )
2754 {
2755 CHAR16 *VlanStr;
2756 VLAN_DEVICE_PATH *Vlan;
2757
2758 VlanStr = GetNextParamStr (&TextDeviceNode);
2759 Vlan = (VLAN_DEVICE_PATH *) CreateDeviceNode (
2760 MESSAGING_DEVICE_PATH,
2761 MSG_VLAN_DP,
2762 (UINT16) sizeof (VLAN_DEVICE_PATH)
2763 );
2764
2765 Vlan->VlanId = (UINT16) Strtoi (VlanStr);
2766
2767 return (EFI_DEVICE_PATH_PROTOCOL *) Vlan;
2768 }
2769
2770 /**
2771 Converts a text device path node to Bluetooth device path structure.
2772
2773 @param TextDeviceNode The input Text device path node.
2774
2775 @return A pointer to the newly-created Bluetooth device path structure.
2776
2777 **/
2778 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextBluetooth(IN CHAR16 * TextDeviceNode)2779 DevPathFromTextBluetooth (
2780 IN CHAR16 *TextDeviceNode
2781 )
2782 {
2783 CHAR16 *BluetoothStr;
2784 CHAR16 *Walker;
2785 CHAR16 *TempNumBuffer;
2786 UINTN TempBufferSize;
2787 INT32 Index;
2788 BLUETOOTH_DEVICE_PATH *BluetoothDp;
2789
2790 BluetoothStr = GetNextParamStr (&TextDeviceNode);
2791 BluetoothDp = (BLUETOOTH_DEVICE_PATH *) CreateDeviceNode (
2792 MESSAGING_DEVICE_PATH,
2793 MSG_BLUETOOTH_DP,
2794 (UINT16) sizeof (BLUETOOTH_DEVICE_PATH)
2795 );
2796
2797 Index = sizeof (BLUETOOTH_ADDRESS) - 1;
2798 Walker = BluetoothStr;
2799 while (!IS_NULL(*Walker) && Index >= 0) {
2800 TempBufferSize = 2 * sizeof(CHAR16) + StrSize(L"0x");
2801 TempNumBuffer = AllocateZeroPool (TempBufferSize);
2802 if (TempNumBuffer == NULL) {
2803 break;
2804 }
2805 StrCpyS (TempNumBuffer, TempBufferSize / sizeof (CHAR16), L"0x");
2806 StrnCatS (TempNumBuffer, TempBufferSize / sizeof (CHAR16), Walker, 2);
2807 BluetoothDp->BD_ADDR.Address[Index] = (UINT8)Strtoi (TempNumBuffer);
2808 FreePool (TempNumBuffer);
2809 Walker += 2;
2810 Index--;
2811 }
2812
2813 return (EFI_DEVICE_PATH_PROTOCOL *) BluetoothDp;
2814 }
2815
2816 /**
2817 Converts a text device path node to Wi-Fi device path structure.
2818
2819 @param TextDeviceNode The input Text device path node.
2820
2821 @return A pointer to the newly-created Wi-Fi device path structure.
2822
2823 **/
2824 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextWiFi(IN CHAR16 * TextDeviceNode)2825 DevPathFromTextWiFi (
2826 IN CHAR16 *TextDeviceNode
2827 )
2828 {
2829 CHAR16 *SSIdStr;
2830 CHAR8 AsciiStr[33];
2831 UINTN DataLen;
2832 WIFI_DEVICE_PATH *WiFiDp;
2833
2834 SSIdStr = GetNextParamStr (&TextDeviceNode);
2835 WiFiDp = (WIFI_DEVICE_PATH *) CreateDeviceNode (
2836 MESSAGING_DEVICE_PATH,
2837 MSG_WIFI_DP,
2838 (UINT16) sizeof (WIFI_DEVICE_PATH)
2839 );
2840
2841 if (NULL != SSIdStr) {
2842 DataLen = StrLen (SSIdStr);
2843 if (StrLen (SSIdStr) > 32) {
2844 SSIdStr[32] = L'\0';
2845 DataLen = 32;
2846 }
2847
2848 UnicodeStrToAsciiStr (SSIdStr, AsciiStr);
2849 CopyMem (WiFiDp->SSId, AsciiStr, DataLen);
2850 }
2851
2852 return (EFI_DEVICE_PATH_PROTOCOL *) WiFiDp;
2853 }
2854
2855 /**
2856 Converts a text device path node to URI device path structure.
2857
2858 @param TextDeviceNode The input Text device path node.
2859
2860 @return A pointer to the newly-created URI device path structure.
2861
2862 **/
2863 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUri(IN CHAR16 * TextDeviceNode)2864 DevPathFromTextUri (
2865 IN CHAR16 *TextDeviceNode
2866 )
2867 {
2868 CHAR16 *UriStr;
2869 UINTN UriLength;
2870 URI_DEVICE_PATH *Uri;
2871
2872 UriStr = GetNextParamStr (&TextDeviceNode);
2873 UriLength = StrnLenS (UriStr, MAX_UINT16 - sizeof (URI_DEVICE_PATH));
2874 Uri = (URI_DEVICE_PATH *) CreateDeviceNode (
2875 MESSAGING_DEVICE_PATH,
2876 MSG_URI_DP,
2877 (UINT16) (sizeof (URI_DEVICE_PATH) + UriLength)
2878 );
2879
2880 while (UriLength-- != 0) {
2881 Uri->Uri[UriLength] = (CHAR8) UriStr[UriLength];
2882 }
2883
2884 return (EFI_DEVICE_PATH_PROTOCOL *) Uri;
2885 }
2886
2887 /**
2888 Converts a media text device path node to media device path structure.
2889
2890 @param TextDeviceNode The input Text device path node.
2891
2892 @return A pointer to media device path structure.
2893
2894 **/
2895 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextMediaPath(IN CHAR16 * TextDeviceNode)2896 DevPathFromTextMediaPath (
2897 IN CHAR16 *TextDeviceNode
2898 )
2899 {
2900 return DevPathFromTextGenericPath (MEDIA_DEVICE_PATH, TextDeviceNode);
2901 }
2902
2903 /**
2904 Converts a text device path node to HD device path structure.
2905
2906 @param TextDeviceNode The input Text device path node.
2907
2908 @return A pointer to the newly-created HD device path structure.
2909
2910 **/
2911 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextHD(IN CHAR16 * TextDeviceNode)2912 DevPathFromTextHD (
2913 IN CHAR16 *TextDeviceNode
2914 )
2915 {
2916 CHAR16 *PartitionStr;
2917 CHAR16 *TypeStr;
2918 CHAR16 *SignatureStr;
2919 CHAR16 *StartStr;
2920 CHAR16 *SizeStr;
2921 UINT32 Signature32;
2922 EFI_GUID SignatureGuid;
2923 HARDDRIVE_DEVICE_PATH *Hd;
2924
2925 PartitionStr = GetNextParamStr (&TextDeviceNode);
2926 TypeStr = GetNextParamStr (&TextDeviceNode);
2927 SignatureStr = GetNextParamStr (&TextDeviceNode);
2928 StartStr = GetNextParamStr (&TextDeviceNode);
2929 SizeStr = GetNextParamStr (&TextDeviceNode);
2930 Hd = (HARDDRIVE_DEVICE_PATH *) CreateDeviceNode (
2931 MEDIA_DEVICE_PATH,
2932 MEDIA_HARDDRIVE_DP,
2933 (UINT16) sizeof (HARDDRIVE_DEVICE_PATH)
2934 );
2935
2936 Hd->PartitionNumber = (UINT32) Strtoi (PartitionStr);
2937
2938 ZeroMem (Hd->Signature, 16);
2939 Hd->MBRType = (UINT8) 0;
2940
2941 if (StrCmp (TypeStr, L"MBR") == 0) {
2942 Hd->SignatureType = SIGNATURE_TYPE_MBR;
2943 Hd->MBRType = 0x01;
2944
2945 Signature32 = (UINT32) Strtoi (SignatureStr);
2946 CopyMem (Hd->Signature, &Signature32, sizeof (UINT32));
2947 } else if (StrCmp (TypeStr, L"GPT") == 0) {
2948 Hd->SignatureType = SIGNATURE_TYPE_GUID;
2949 Hd->MBRType = 0x02;
2950
2951 StrToGuid (SignatureStr, &SignatureGuid);
2952 CopyMem (Hd->Signature, &SignatureGuid, sizeof (EFI_GUID));
2953 } else {
2954 Hd->SignatureType = (UINT8) Strtoi (TypeStr);
2955 }
2956
2957 Strtoi64 (StartStr, &Hd->PartitionStart);
2958 Strtoi64 (SizeStr, &Hd->PartitionSize);
2959
2960 return (EFI_DEVICE_PATH_PROTOCOL *) Hd;
2961 }
2962
2963 /**
2964 Converts a text device path node to CDROM device path structure.
2965
2966 @param TextDeviceNode The input Text device path node.
2967
2968 @return A pointer to the newly-created CDROM device path structure.
2969
2970 **/
2971 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextCDROM(IN CHAR16 * TextDeviceNode)2972 DevPathFromTextCDROM (
2973 IN CHAR16 *TextDeviceNode
2974 )
2975 {
2976 CHAR16 *EntryStr;
2977 CHAR16 *StartStr;
2978 CHAR16 *SizeStr;
2979 CDROM_DEVICE_PATH *CDROMDevPath;
2980
2981 EntryStr = GetNextParamStr (&TextDeviceNode);
2982 StartStr = GetNextParamStr (&TextDeviceNode);
2983 SizeStr = GetNextParamStr (&TextDeviceNode);
2984 CDROMDevPath = (CDROM_DEVICE_PATH *) CreateDeviceNode (
2985 MEDIA_DEVICE_PATH,
2986 MEDIA_CDROM_DP,
2987 (UINT16) sizeof (CDROM_DEVICE_PATH)
2988 );
2989
2990 CDROMDevPath->BootEntry = (UINT32) Strtoi (EntryStr);
2991 Strtoi64 (StartStr, &CDROMDevPath->PartitionStart);
2992 Strtoi64 (SizeStr, &CDROMDevPath->PartitionSize);
2993
2994 return (EFI_DEVICE_PATH_PROTOCOL *) CDROMDevPath;
2995 }
2996
2997 /**
2998 Converts a text device path node to Vendor-defined media device path structure.
2999
3000 @param TextDeviceNode The input Text device path node.
3001
3002 @return A pointer to the newly-created Vendor-defined media device path structure.
3003
3004 **/
3005 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextVenMedia(IN CHAR16 * TextDeviceNode)3006 DevPathFromTextVenMedia (
3007 IN CHAR16 *TextDeviceNode
3008 )
3009 {
3010 return ConvertFromTextVendor (
3011 TextDeviceNode,
3012 MEDIA_DEVICE_PATH,
3013 MEDIA_VENDOR_DP
3014 );
3015 }
3016
3017 /**
3018 Converts a text device path node to File device path structure.
3019
3020 @param TextDeviceNode The input Text device path node.
3021
3022 @return A pointer to the newly-created File device path structure.
3023
3024 **/
3025 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextFilePath(IN CHAR16 * TextDeviceNode)3026 DevPathFromTextFilePath (
3027 IN CHAR16 *TextDeviceNode
3028 )
3029 {
3030 FILEPATH_DEVICE_PATH *File;
3031
3032 File = (FILEPATH_DEVICE_PATH *) CreateDeviceNode (
3033 MEDIA_DEVICE_PATH,
3034 MEDIA_FILEPATH_DP,
3035 (UINT16) (sizeof (FILEPATH_DEVICE_PATH) + StrLen (TextDeviceNode) * 2)
3036 );
3037
3038 StrCpyS (File->PathName, StrLen (TextDeviceNode) + 1, TextDeviceNode);
3039
3040 return (EFI_DEVICE_PATH_PROTOCOL *) File;
3041 }
3042
3043 /**
3044 Converts a text device path node to Media protocol device path structure.
3045
3046 @param TextDeviceNode The input Text device path node.
3047
3048 @return A pointer to the newly-created Media protocol device path structure.
3049
3050 **/
3051 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextMedia(IN CHAR16 * TextDeviceNode)3052 DevPathFromTextMedia (
3053 IN CHAR16 *TextDeviceNode
3054 )
3055 {
3056 CHAR16 *GuidStr;
3057 MEDIA_PROTOCOL_DEVICE_PATH *Media;
3058
3059 GuidStr = GetNextParamStr (&TextDeviceNode);
3060 Media = (MEDIA_PROTOCOL_DEVICE_PATH *) CreateDeviceNode (
3061 MEDIA_DEVICE_PATH,
3062 MEDIA_PROTOCOL_DP,
3063 (UINT16) sizeof (MEDIA_PROTOCOL_DEVICE_PATH)
3064 );
3065
3066 StrToGuid (GuidStr, &Media->Protocol);
3067
3068 return (EFI_DEVICE_PATH_PROTOCOL *) Media;
3069 }
3070
3071 /**
3072 Converts a text device path node to firmware volume device path structure.
3073
3074 @param TextDeviceNode The input Text device path node.
3075
3076 @return A pointer to the newly-created firmware volume device path structure.
3077
3078 **/
3079 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextFv(IN CHAR16 * TextDeviceNode)3080 DevPathFromTextFv (
3081 IN CHAR16 *TextDeviceNode
3082 )
3083 {
3084 CHAR16 *GuidStr;
3085 MEDIA_FW_VOL_DEVICE_PATH *Fv;
3086
3087 GuidStr = GetNextParamStr (&TextDeviceNode);
3088 Fv = (MEDIA_FW_VOL_DEVICE_PATH *) CreateDeviceNode (
3089 MEDIA_DEVICE_PATH,
3090 MEDIA_PIWG_FW_VOL_DP,
3091 (UINT16) sizeof (MEDIA_FW_VOL_DEVICE_PATH)
3092 );
3093
3094 StrToGuid (GuidStr, &Fv->FvName);
3095
3096 return (EFI_DEVICE_PATH_PROTOCOL *) Fv;
3097 }
3098
3099 /**
3100 Converts a text device path node to firmware file device path structure.
3101
3102 @param TextDeviceNode The input Text device path node.
3103
3104 @return A pointer to the newly-created firmware file device path structure.
3105
3106 **/
3107 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextFvFile(IN CHAR16 * TextDeviceNode)3108 DevPathFromTextFvFile (
3109 IN CHAR16 *TextDeviceNode
3110 )
3111 {
3112 CHAR16 *GuidStr;
3113 MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *FvFile;
3114
3115 GuidStr = GetNextParamStr (&TextDeviceNode);
3116 FvFile = (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) CreateDeviceNode (
3117 MEDIA_DEVICE_PATH,
3118 MEDIA_PIWG_FW_FILE_DP,
3119 (UINT16) sizeof (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH)
3120 );
3121
3122 StrToGuid (GuidStr, &FvFile->FvFileName);
3123
3124 return (EFI_DEVICE_PATH_PROTOCOL *) FvFile;
3125 }
3126
3127 /**
3128 Converts a text device path node to text relative offset device path structure.
3129
3130 @param TextDeviceNode The input Text device path node.
3131
3132 @return A pointer to the newly-created Text device path structure.
3133
3134 **/
3135 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextRelativeOffsetRange(IN CHAR16 * TextDeviceNode)3136 DevPathFromTextRelativeOffsetRange (
3137 IN CHAR16 *TextDeviceNode
3138 )
3139 {
3140 CHAR16 *StartingOffsetStr;
3141 CHAR16 *EndingOffsetStr;
3142 MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH *Offset;
3143
3144 StartingOffsetStr = GetNextParamStr (&TextDeviceNode);
3145 EndingOffsetStr = GetNextParamStr (&TextDeviceNode);
3146 Offset = (MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH *) CreateDeviceNode (
3147 MEDIA_DEVICE_PATH,
3148 MEDIA_RELATIVE_OFFSET_RANGE_DP,
3149 (UINT16) sizeof (MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH)
3150 );
3151
3152 Strtoi64 (StartingOffsetStr, &Offset->StartingOffset);
3153 Strtoi64 (EndingOffsetStr, &Offset->EndingOffset);
3154
3155 return (EFI_DEVICE_PATH_PROTOCOL *) Offset;
3156 }
3157
3158 /**
3159 Converts a text device path node to text ram disk device path structure.
3160
3161 @param TextDeviceNode The input Text device path node.
3162
3163 @return A pointer to the newly-created Text device path structure.
3164
3165 **/
3166 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextRamDisk(IN CHAR16 * TextDeviceNode)3167 DevPathFromTextRamDisk (
3168 IN CHAR16 *TextDeviceNode
3169 )
3170 {
3171 CHAR16 *StartingAddrStr;
3172 CHAR16 *EndingAddrStr;
3173 CHAR16 *TypeGuidStr;
3174 CHAR16 *InstanceStr;
3175 MEDIA_RAM_DISK_DEVICE_PATH *RamDisk;
3176 UINT64 StartingAddr;
3177 UINT64 EndingAddr;
3178
3179 StartingAddrStr = GetNextParamStr (&TextDeviceNode);
3180 EndingAddrStr = GetNextParamStr (&TextDeviceNode);
3181 InstanceStr = GetNextParamStr (&TextDeviceNode);
3182 TypeGuidStr = GetNextParamStr (&TextDeviceNode);
3183 RamDisk = (MEDIA_RAM_DISK_DEVICE_PATH *) CreateDeviceNode (
3184 MEDIA_DEVICE_PATH,
3185 MEDIA_RAM_DISK_DP,
3186 (UINT16) sizeof (MEDIA_RAM_DISK_DEVICE_PATH)
3187 );
3188
3189 Strtoi64 (StartingAddrStr, &StartingAddr);
3190 WriteUnaligned64 ((UINT64 *) &(RamDisk->StartingAddr[0]), StartingAddr);
3191 Strtoi64 (EndingAddrStr, &EndingAddr);
3192 WriteUnaligned64 ((UINT64 *) &(RamDisk->EndingAddr[0]), EndingAddr);
3193 RamDisk->Instance = (UINT16) Strtoi (InstanceStr);
3194 StrToGuid (TypeGuidStr, &RamDisk->TypeGuid);
3195
3196 return (EFI_DEVICE_PATH_PROTOCOL *) RamDisk;
3197 }
3198
3199 /**
3200 Converts a text device path node to text virtual disk device path structure.
3201
3202 @param TextDeviceNode The input Text device path node.
3203
3204 @return A pointer to the newly-created Text device path structure.
3205
3206 **/
3207 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextVirtualDisk(IN CHAR16 * TextDeviceNode)3208 DevPathFromTextVirtualDisk (
3209 IN CHAR16 *TextDeviceNode
3210 )
3211 {
3212 CHAR16 *StartingAddrStr;
3213 CHAR16 *EndingAddrStr;
3214 CHAR16 *InstanceStr;
3215 MEDIA_RAM_DISK_DEVICE_PATH *RamDisk;
3216 UINT64 StartingAddr;
3217 UINT64 EndingAddr;
3218
3219 StartingAddrStr = GetNextParamStr (&TextDeviceNode);
3220 EndingAddrStr = GetNextParamStr (&TextDeviceNode);
3221 InstanceStr = GetNextParamStr (&TextDeviceNode);
3222
3223 RamDisk = (MEDIA_RAM_DISK_DEVICE_PATH *) CreateDeviceNode (
3224 MEDIA_DEVICE_PATH,
3225 MEDIA_RAM_DISK_DP,
3226 (UINT16) sizeof (MEDIA_RAM_DISK_DEVICE_PATH)
3227 );
3228
3229 Strtoi64 (StartingAddrStr, &StartingAddr);
3230 WriteUnaligned64 ((UINT64 *) &(RamDisk->StartingAddr[0]), StartingAddr);
3231 Strtoi64 (EndingAddrStr, &EndingAddr);
3232 WriteUnaligned64 ((UINT64 *) &(RamDisk->EndingAddr[0]), EndingAddr);
3233 RamDisk->Instance = (UINT16) Strtoi (InstanceStr);
3234 CopyGuid (&RamDisk->TypeGuid, &gEfiVirtualDiskGuid);
3235
3236 return (EFI_DEVICE_PATH_PROTOCOL *) RamDisk;
3237 }
3238
3239 /**
3240 Converts a text device path node to text virtual cd device path structure.
3241
3242 @param TextDeviceNode The input Text device path node.
3243
3244 @return A pointer to the newly-created Text device path structure.
3245
3246 **/
3247 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextVirtualCd(IN CHAR16 * TextDeviceNode)3248 DevPathFromTextVirtualCd (
3249 IN CHAR16 *TextDeviceNode
3250 )
3251 {
3252 CHAR16 *StartingAddrStr;
3253 CHAR16 *EndingAddrStr;
3254 CHAR16 *InstanceStr;
3255 MEDIA_RAM_DISK_DEVICE_PATH *RamDisk;
3256 UINT64 StartingAddr;
3257 UINT64 EndingAddr;
3258
3259 StartingAddrStr = GetNextParamStr (&TextDeviceNode);
3260 EndingAddrStr = GetNextParamStr (&TextDeviceNode);
3261 InstanceStr = GetNextParamStr (&TextDeviceNode);
3262
3263 RamDisk = (MEDIA_RAM_DISK_DEVICE_PATH *) CreateDeviceNode (
3264 MEDIA_DEVICE_PATH,
3265 MEDIA_RAM_DISK_DP,
3266 (UINT16) sizeof (MEDIA_RAM_DISK_DEVICE_PATH)
3267 );
3268
3269 Strtoi64 (StartingAddrStr, &StartingAddr);
3270 WriteUnaligned64 ((UINT64 *) &(RamDisk->StartingAddr[0]), StartingAddr);
3271 Strtoi64 (EndingAddrStr, &EndingAddr);
3272 WriteUnaligned64 ((UINT64 *) &(RamDisk->EndingAddr[0]), EndingAddr);
3273 RamDisk->Instance = (UINT16) Strtoi (InstanceStr);
3274 CopyGuid (&RamDisk->TypeGuid, &gEfiVirtualCdGuid);
3275
3276 return (EFI_DEVICE_PATH_PROTOCOL *) RamDisk;
3277 }
3278
3279 /**
3280 Converts a text device path node to text persistent virtual disk device path structure.
3281
3282 @param TextDeviceNode The input Text device path node.
3283
3284 @return A pointer to the newly-created Text device path structure.
3285
3286 **/
3287 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextPersistentVirtualDisk(IN CHAR16 * TextDeviceNode)3288 DevPathFromTextPersistentVirtualDisk (
3289 IN CHAR16 *TextDeviceNode
3290 )
3291 {
3292 CHAR16 *StartingAddrStr;
3293 CHAR16 *EndingAddrStr;
3294 CHAR16 *InstanceStr;
3295 MEDIA_RAM_DISK_DEVICE_PATH *RamDisk;
3296 UINT64 StartingAddr;
3297 UINT64 EndingAddr;
3298
3299 StartingAddrStr = GetNextParamStr (&TextDeviceNode);
3300 EndingAddrStr = GetNextParamStr (&TextDeviceNode);
3301 InstanceStr = GetNextParamStr (&TextDeviceNode);
3302
3303 RamDisk = (MEDIA_RAM_DISK_DEVICE_PATH *) CreateDeviceNode (
3304 MEDIA_DEVICE_PATH,
3305 MEDIA_RAM_DISK_DP,
3306 (UINT16) sizeof (MEDIA_RAM_DISK_DEVICE_PATH)
3307 );
3308
3309 Strtoi64 (StartingAddrStr, &StartingAddr);
3310 WriteUnaligned64 ((UINT64 *) &(RamDisk->StartingAddr[0]), StartingAddr);
3311 Strtoi64 (EndingAddrStr, &EndingAddr);
3312 WriteUnaligned64 ((UINT64 *) &(RamDisk->EndingAddr[0]), EndingAddr);
3313 RamDisk->Instance = (UINT16) Strtoi (InstanceStr);
3314 CopyGuid (&RamDisk->TypeGuid, &gEfiPersistentVirtualDiskGuid);
3315
3316 return (EFI_DEVICE_PATH_PROTOCOL *) RamDisk;
3317 }
3318
3319 /**
3320 Converts a text device path node to text persistent virtual cd device path structure.
3321
3322 @param TextDeviceNode The input Text device path node.
3323
3324 @return A pointer to the newly-created Text device path structure.
3325
3326 **/
3327 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextPersistentVirtualCd(IN CHAR16 * TextDeviceNode)3328 DevPathFromTextPersistentVirtualCd (
3329 IN CHAR16 *TextDeviceNode
3330 )
3331 {
3332 CHAR16 *StartingAddrStr;
3333 CHAR16 *EndingAddrStr;
3334 CHAR16 *InstanceStr;
3335 MEDIA_RAM_DISK_DEVICE_PATH *RamDisk;
3336 UINT64 StartingAddr;
3337 UINT64 EndingAddr;
3338
3339 StartingAddrStr = GetNextParamStr (&TextDeviceNode);
3340 EndingAddrStr = GetNextParamStr (&TextDeviceNode);
3341 InstanceStr = GetNextParamStr (&TextDeviceNode);
3342
3343 RamDisk = (MEDIA_RAM_DISK_DEVICE_PATH *) CreateDeviceNode (
3344 MEDIA_DEVICE_PATH,
3345 MEDIA_RAM_DISK_DP,
3346 (UINT16) sizeof (MEDIA_RAM_DISK_DEVICE_PATH)
3347 );
3348
3349 Strtoi64 (StartingAddrStr, &StartingAddr);
3350 WriteUnaligned64 ((UINT64 *) &(RamDisk->StartingAddr[0]), StartingAddr);
3351 Strtoi64 (EndingAddrStr, &EndingAddr);
3352 WriteUnaligned64 ((UINT64 *) &(RamDisk->EndingAddr[0]), EndingAddr);
3353 RamDisk->Instance = (UINT16) Strtoi (InstanceStr);
3354 CopyGuid (&RamDisk->TypeGuid, &gEfiPersistentVirtualCdGuid);
3355
3356 return (EFI_DEVICE_PATH_PROTOCOL *) RamDisk;
3357 }
3358
3359 /**
3360 Converts a BBS text device path node to BBS device path structure.
3361
3362 @param TextDeviceNode The input Text device path node.
3363
3364 @return A pointer to BBS device path structure.
3365
3366 **/
3367 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextBbsPath(IN CHAR16 * TextDeviceNode)3368 DevPathFromTextBbsPath (
3369 IN CHAR16 *TextDeviceNode
3370 )
3371 {
3372 return DevPathFromTextGenericPath (BBS_DEVICE_PATH, TextDeviceNode);
3373 }
3374
3375 /**
3376 Converts a text device path node to BIOS Boot Specification device path structure.
3377
3378 @param TextDeviceNode The input Text device path node.
3379
3380 @return A pointer to the newly-created BIOS Boot Specification device path structure.
3381
3382 **/
3383 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextBBS(IN CHAR16 * TextDeviceNode)3384 DevPathFromTextBBS (
3385 IN CHAR16 *TextDeviceNode
3386 )
3387 {
3388 CHAR16 *TypeStr;
3389 CHAR16 *IdStr;
3390 CHAR16 *FlagsStr;
3391 CHAR8 *AsciiStr;
3392 BBS_BBS_DEVICE_PATH *Bbs;
3393
3394 TypeStr = GetNextParamStr (&TextDeviceNode);
3395 IdStr = GetNextParamStr (&TextDeviceNode);
3396 FlagsStr = GetNextParamStr (&TextDeviceNode);
3397 Bbs = (BBS_BBS_DEVICE_PATH *) CreateDeviceNode (
3398 BBS_DEVICE_PATH,
3399 BBS_BBS_DP,
3400 (UINT16) (sizeof (BBS_BBS_DEVICE_PATH) + StrLen (IdStr))
3401 );
3402
3403 if (StrCmp (TypeStr, L"Floppy") == 0) {
3404 Bbs->DeviceType = BBS_TYPE_FLOPPY;
3405 } else if (StrCmp (TypeStr, L"HD") == 0) {
3406 Bbs->DeviceType = BBS_TYPE_HARDDRIVE;
3407 } else if (StrCmp (TypeStr, L"CDROM") == 0) {
3408 Bbs->DeviceType = BBS_TYPE_CDROM;
3409 } else if (StrCmp (TypeStr, L"PCMCIA") == 0) {
3410 Bbs->DeviceType = BBS_TYPE_PCMCIA;
3411 } else if (StrCmp (TypeStr, L"USB") == 0) {
3412 Bbs->DeviceType = BBS_TYPE_USB;
3413 } else if (StrCmp (TypeStr, L"Network") == 0) {
3414 Bbs->DeviceType = BBS_TYPE_EMBEDDED_NETWORK;
3415 } else {
3416 Bbs->DeviceType = (UINT16) Strtoi (TypeStr);
3417 }
3418
3419 AsciiStr = Bbs->String;
3420 StrToAscii (IdStr, &AsciiStr);
3421
3422 Bbs->StatusFlag = (UINT16) Strtoi (FlagsStr);
3423
3424 return (EFI_DEVICE_PATH_PROTOCOL *) Bbs;
3425 }
3426
3427 /**
3428 Converts a text device path node to SATA device path structure.
3429
3430 @param TextDeviceNode The input Text device path node.
3431
3432 @return A pointer to the newly-created SATA device path structure.
3433
3434 **/
3435 EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextSata(IN CHAR16 * TextDeviceNode)3436 DevPathFromTextSata (
3437 IN CHAR16 *TextDeviceNode
3438 )
3439 {
3440 SATA_DEVICE_PATH *Sata;
3441 CHAR16 *Param1;
3442 CHAR16 *Param2;
3443 CHAR16 *Param3;
3444
3445 Param1 = GetNextParamStr (&TextDeviceNode);
3446 Param2 = GetNextParamStr (&TextDeviceNode);
3447 Param3 = GetNextParamStr (&TextDeviceNode);
3448
3449 Sata = (SATA_DEVICE_PATH *) CreateDeviceNode (
3450 MESSAGING_DEVICE_PATH,
3451 MSG_SATA_DP,
3452 (UINT16) sizeof (SATA_DEVICE_PATH)
3453 );
3454 Sata->HBAPortNumber = (UINT16) Strtoi (Param1);
3455 Sata->PortMultiplierPortNumber = (UINT16) Strtoi (Param2);
3456 Sata->Lun = (UINT16) Strtoi (Param3);
3457
3458 return (EFI_DEVICE_PATH_PROTOCOL *) Sata;
3459 }
3460
3461 GLOBAL_REMOVE_IF_UNREFERENCED DEVICE_PATH_FROM_TEXT_TABLE mUefiDevicePathLibDevPathFromTextTable[] = {
3462 {L"Path", DevPathFromTextPath },
3463
3464 {L"HardwarePath", DevPathFromTextHardwarePath },
3465 {L"Pci", DevPathFromTextPci },
3466 {L"PcCard", DevPathFromTextPcCard },
3467 {L"MemoryMapped", DevPathFromTextMemoryMapped },
3468 {L"VenHw", DevPathFromTextVenHw },
3469 {L"Ctrl", DevPathFromTextCtrl },
3470 {L"BMC", DevPathFromTextBmc },
3471
3472 {L"AcpiPath", DevPathFromTextAcpiPath },
3473 {L"Acpi", DevPathFromTextAcpi },
3474 {L"PciRoot", DevPathFromTextPciRoot },
3475 {L"PcieRoot", DevPathFromTextPcieRoot },
3476 {L"Floppy", DevPathFromTextFloppy },
3477 {L"Keyboard", DevPathFromTextKeyboard },
3478 {L"Serial", DevPathFromTextSerial },
3479 {L"ParallelPort", DevPathFromTextParallelPort },
3480 {L"AcpiEx", DevPathFromTextAcpiEx },
3481 {L"AcpiExp", DevPathFromTextAcpiExp },
3482 {L"AcpiAdr", DevPathFromTextAcpiAdr },
3483
3484 {L"Msg", DevPathFromTextMsg },
3485 {L"Ata", DevPathFromTextAta },
3486 {L"Scsi", DevPathFromTextScsi },
3487 {L"Fibre", DevPathFromTextFibre },
3488 {L"FibreEx", DevPathFromTextFibreEx },
3489 {L"I1394", DevPathFromText1394 },
3490 {L"USB", DevPathFromTextUsb },
3491 {L"I2O", DevPathFromTextI2O },
3492 {L"Infiniband", DevPathFromTextInfiniband },
3493 {L"VenMsg", DevPathFromTextVenMsg },
3494 {L"VenPcAnsi", DevPathFromTextVenPcAnsi },
3495 {L"VenVt100", DevPathFromTextVenVt100 },
3496 {L"VenVt100Plus", DevPathFromTextVenVt100Plus },
3497 {L"VenUtf8", DevPathFromTextVenUtf8 },
3498 {L"UartFlowCtrl", DevPathFromTextUartFlowCtrl },
3499 {L"SAS", DevPathFromTextSAS },
3500 {L"SasEx", DevPathFromTextSasEx },
3501 {L"NVMe", DevPathFromTextNVMe },
3502 {L"UFS", DevPathFromTextUfs },
3503 {L"SD", DevPathFromTextSd },
3504 {L"DebugPort", DevPathFromTextDebugPort },
3505 {L"MAC", DevPathFromTextMAC },
3506 {L"IPv4", DevPathFromTextIPv4 },
3507 {L"IPv6", DevPathFromTextIPv6 },
3508 {L"Uart", DevPathFromTextUart },
3509 {L"UsbClass", DevPathFromTextUsbClass },
3510 {L"UsbAudio", DevPathFromTextUsbAudio },
3511 {L"UsbCDCControl", DevPathFromTextUsbCDCControl },
3512 {L"UsbHID", DevPathFromTextUsbHID },
3513 {L"UsbImage", DevPathFromTextUsbImage },
3514 {L"UsbPrinter", DevPathFromTextUsbPrinter },
3515 {L"UsbMassStorage", DevPathFromTextUsbMassStorage },
3516 {L"UsbHub", DevPathFromTextUsbHub },
3517 {L"UsbCDCData", DevPathFromTextUsbCDCData },
3518 {L"UsbSmartCard", DevPathFromTextUsbSmartCard },
3519 {L"UsbVideo", DevPathFromTextUsbVideo },
3520 {L"UsbDiagnostic", DevPathFromTextUsbDiagnostic },
3521 {L"UsbWireless", DevPathFromTextUsbWireless },
3522 {L"UsbDeviceFirmwareUpdate", DevPathFromTextUsbDeviceFirmwareUpdate },
3523 {L"UsbIrdaBridge", DevPathFromTextUsbIrdaBridge },
3524 {L"UsbTestAndMeasurement", DevPathFromTextUsbTestAndMeasurement },
3525 {L"UsbWwid", DevPathFromTextUsbWwid },
3526 {L"Unit", DevPathFromTextUnit },
3527 {L"iSCSI", DevPathFromTextiSCSI },
3528 {L"Vlan", DevPathFromTextVlan },
3529 {L"Uri", DevPathFromTextUri },
3530 {L"Bluetooth", DevPathFromTextBluetooth },
3531 {L"Wi-Fi", DevPathFromTextWiFi },
3532 {L"MediaPath", DevPathFromTextMediaPath },
3533 {L"HD", DevPathFromTextHD },
3534 {L"CDROM", DevPathFromTextCDROM },
3535 {L"VenMedia", DevPathFromTextVenMedia },
3536 {L"Media", DevPathFromTextMedia },
3537 {L"Fv", DevPathFromTextFv },
3538 {L"FvFile", DevPathFromTextFvFile },
3539 {L"Offset", DevPathFromTextRelativeOffsetRange },
3540 {L"RamDisk", DevPathFromTextRamDisk },
3541 {L"VirtualDisk", DevPathFromTextVirtualDisk },
3542 {L"VirtualCD", DevPathFromTextVirtualCd },
3543 {L"PersistentVirtualDisk", DevPathFromTextPersistentVirtualDisk },
3544 {L"PersistentVirtualCD", DevPathFromTextPersistentVirtualCd },
3545
3546 {L"BbsPath", DevPathFromTextBbsPath },
3547 {L"BBS", DevPathFromTextBBS },
3548 {L"Sata", DevPathFromTextSata },
3549 {NULL, NULL}
3550 };
3551
3552 /**
3553 Convert text to the binary representation of a device node.
3554
3555 @param TextDeviceNode TextDeviceNode points to the text representation of a device
3556 node. Conversion starts with the first character and continues
3557 until the first non-device node character.
3558
3559 @return A pointer to the EFI device node or NULL if TextDeviceNode is NULL or there was
3560 insufficient memory or text unsupported.
3561
3562 **/
3563 EFI_DEVICE_PATH_PROTOCOL *
3564 EFIAPI
UefiDevicePathLibConvertTextToDeviceNode(IN CONST CHAR16 * TextDeviceNode)3565 UefiDevicePathLibConvertTextToDeviceNode (
3566 IN CONST CHAR16 *TextDeviceNode
3567 )
3568 {
3569 DEVICE_PATH_FROM_TEXT FromText;
3570 CHAR16 *ParamStr;
3571 EFI_DEVICE_PATH_PROTOCOL *DeviceNode;
3572 CHAR16 *DeviceNodeStr;
3573 UINTN Index;
3574
3575 if ((TextDeviceNode == NULL) || (IS_NULL (*TextDeviceNode))) {
3576 return NULL;
3577 }
3578
3579 ParamStr = NULL;
3580 FromText = NULL;
3581 DeviceNodeStr = UefiDevicePathLibStrDuplicate (TextDeviceNode);
3582 ASSERT (DeviceNodeStr != NULL);
3583
3584 for (Index = 0; mUefiDevicePathLibDevPathFromTextTable[Index].Function != NULL; Index++) {
3585 ParamStr = GetParamByNodeName (DeviceNodeStr, mUefiDevicePathLibDevPathFromTextTable[Index].DevicePathNodeText);
3586 if (ParamStr != NULL) {
3587 FromText = mUefiDevicePathLibDevPathFromTextTable[Index].Function;
3588 break;
3589 }
3590 }
3591
3592 if (FromText == NULL) {
3593 //
3594 // A file path
3595 //
3596 FromText = DevPathFromTextFilePath;
3597 DeviceNode = FromText (DeviceNodeStr);
3598 } else {
3599 DeviceNode = FromText (ParamStr);
3600 FreePool (ParamStr);
3601 }
3602
3603 FreePool (DeviceNodeStr);
3604
3605 return DeviceNode;
3606 }
3607
3608 /**
3609 Convert text to the binary representation of a device path.
3610
3611
3612 @param TextDevicePath TextDevicePath points to the text representation of a device
3613 path. Conversion starts with the first character and continues
3614 until the first non-device node character.
3615
3616 @return A pointer to the allocated device path or NULL if TextDeviceNode is NULL or
3617 there was insufficient memory.
3618
3619 **/
3620 EFI_DEVICE_PATH_PROTOCOL *
3621 EFIAPI
UefiDevicePathLibConvertTextToDevicePath(IN CONST CHAR16 * TextDevicePath)3622 UefiDevicePathLibConvertTextToDevicePath (
3623 IN CONST CHAR16 *TextDevicePath
3624 )
3625 {
3626 EFI_DEVICE_PATH_PROTOCOL *DeviceNode;
3627 EFI_DEVICE_PATH_PROTOCOL *NewDevicePath;
3628 CHAR16 *DevicePathStr;
3629 CHAR16 *Str;
3630 CHAR16 *DeviceNodeStr;
3631 BOOLEAN IsInstanceEnd;
3632 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
3633
3634 if ((TextDevicePath == NULL) || (IS_NULL (*TextDevicePath))) {
3635 return NULL;
3636 }
3637
3638 DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) AllocatePool (END_DEVICE_PATH_LENGTH);
3639 ASSERT (DevicePath != NULL);
3640 SetDevicePathEndNode (DevicePath);
3641
3642 DevicePathStr = UefiDevicePathLibStrDuplicate (TextDevicePath);
3643
3644 Str = DevicePathStr;
3645 while ((DeviceNodeStr = GetNextDeviceNodeStr (&Str, &IsInstanceEnd)) != NULL) {
3646 DeviceNode = UefiDevicePathLibConvertTextToDeviceNode (DeviceNodeStr);
3647
3648 NewDevicePath = AppendDevicePathNode (DevicePath, DeviceNode);
3649 FreePool (DevicePath);
3650 FreePool (DeviceNode);
3651 DevicePath = NewDevicePath;
3652
3653 if (IsInstanceEnd) {
3654 DeviceNode = (EFI_DEVICE_PATH_PROTOCOL *) AllocatePool (END_DEVICE_PATH_LENGTH);
3655 ASSERT (DeviceNode != NULL);
3656 SetDevicePathEndNode (DeviceNode);
3657
3658 NewDevicePath = AppendDevicePathNode (DevicePath, DeviceNode);
3659 FreePool (DevicePath);
3660 FreePool (DeviceNode);
3661 DevicePath = NewDevicePath;
3662 }
3663 }
3664
3665 FreePool (DevicePathStr);
3666 return DevicePath;
3667 }
3668