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