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