]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Universal/DevicePathDxe/DevicePathFromText.c
projects / mirror_edk2.git / blob
? search:


3236291520e5eeec03baa1ee6eba2277f5dca637
[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 UINTN Length;
1157
1158 AcpiAdr = (ACPI_ADR_DEVICE_PATH *) CreateDeviceNode (
1159 ACPI_DEVICE_PATH,
1160 ACPI_ADR_DP,
1161 sizeof (ACPI_ADR_DEVICE_PATH)
1162 );
1163 ASSERT (AcpiAdr != NULL);
1164
1165 for (Index = 0; ; Index++) {
1166 DisplayDeviceStr = GetNextParamStr (&TextDeviceNode);
1167 if (IS_NULL (*DisplayDeviceStr)) {
1168 break;
1169 }
1170 if (Index > 0) {
1171 Length = DevicePathNodeLength (AcpiAdr);
1172 AcpiAdr = ReallocatePool (
1173 Length,
1174 Length + sizeof (UINT32),
1175 AcpiAdr
1176 );
1177 ASSERT (AcpiAdr != NULL);
1178 SetDevicePathNodeLength (AcpiAdr, Length + sizeof (UINT32));
1179 }
1180
1181 (&AcpiAdr->ADR)[Index] = (UINT32) Strtoi (DisplayDeviceStr);
1182 }
1183
1184 return (EFI_DEVICE_PATH_PROTOCOL *) AcpiAdr;
1185 }
1186
1187 /**
1188 Converts a text device path node to Parallel Port device path structure.
1189
1190 @param TextDeviceNode The input Text device path node.
1191
1192 @return A pointer to the newly-created Parallel Port device path structure.
1193
1194 **/
1195 EFI_DEVICE_PATH_PROTOCOL *
1196 DevPathFromTextAta (
1197 IN CHAR16 *TextDeviceNode
1198 )
1199 {
1200 CHAR16 *PrimarySecondaryStr;
1201 CHAR16 *SlaveMasterStr;
1202 CHAR16 *LunStr;
1203 ATAPI_DEVICE_PATH *Atapi;
1204
1205 Atapi = (ATAPI_DEVICE_PATH *) CreateDeviceNode (
1206 MESSAGING_DEVICE_PATH,
1207 MSG_ATAPI_DP,
1208 (UINT16) sizeof (ATAPI_DEVICE_PATH)
1209 );
1210
1211 PrimarySecondaryStr = GetNextParamStr (&TextDeviceNode);
1212 SlaveMasterStr = GetNextParamStr (&TextDeviceNode);
1213 LunStr = GetNextParamStr (&TextDeviceNode);
1214
1215 Atapi->PrimarySecondary = (UINT8) ((StrCmp (PrimarySecondaryStr, L"Primary") == 0) ? 0 : 1);
1216 Atapi->SlaveMaster = (UINT8) ((StrCmp (SlaveMasterStr, L"Master") == 0) ? 0 : 1);
1217 Atapi->Lun = (UINT16) Strtoi (LunStr);
1218
1219 return (EFI_DEVICE_PATH_PROTOCOL *) Atapi;
1220 }
1221
1222 /**
1223 Converts a text device path node to SCSI device path structure.
1224
1225 @param TextDeviceNode The input Text device path node.
1226
1227 @return A pointer to the newly-created SCSI device path structure.
1228
1229 **/
1230 EFI_DEVICE_PATH_PROTOCOL *
1231 DevPathFromTextScsi (
1232 IN CHAR16 *TextDeviceNode
1233 )
1234 {
1235 CHAR16 *PunStr;
1236 CHAR16 *LunStr;
1237 SCSI_DEVICE_PATH *Scsi;
1238
1239 PunStr = GetNextParamStr (&TextDeviceNode);
1240 LunStr = GetNextParamStr (&TextDeviceNode);
1241 Scsi = (SCSI_DEVICE_PATH *) CreateDeviceNode (
1242 MESSAGING_DEVICE_PATH,
1243 MSG_SCSI_DP,
1244 (UINT16) sizeof (SCSI_DEVICE_PATH)
1245 );
1246
1247 Scsi->Pun = (UINT16) Strtoi (PunStr);
1248 Scsi->Lun = (UINT16) Strtoi (LunStr);
1249
1250 return (EFI_DEVICE_PATH_PROTOCOL *) Scsi;
1251 }
1252
1253 /**
1254 Converts a text device path node to Fibre device path structure.
1255
1256 @param TextDeviceNode The input Text device path node.
1257
1258 @return A pointer to the newly-created Fibre device path structure.
1259
1260 **/
1261 EFI_DEVICE_PATH_PROTOCOL *
1262 DevPathFromTextFibre (
1263 IN CHAR16 *TextDeviceNode
1264 )
1265 {
1266 CHAR16 *WWNStr;
1267 CHAR16 *LunStr;
1268 FIBRECHANNEL_DEVICE_PATH *Fibre;
1269
1270 WWNStr = GetNextParamStr (&TextDeviceNode);
1271 LunStr = GetNextParamStr (&TextDeviceNode);
1272 Fibre = (FIBRECHANNEL_DEVICE_PATH *) CreateDeviceNode (
1273 MESSAGING_DEVICE_PATH,
1274 MSG_FIBRECHANNEL_DP,
1275 (UINT16) sizeof (FIBRECHANNEL_DEVICE_PATH)
1276 );
1277
1278 Fibre->Reserved = 0;
1279 Strtoi64 (WWNStr, &Fibre->WWN);
1280 Strtoi64 (LunStr, &Fibre->Lun);
1281
1282 return (EFI_DEVICE_PATH_PROTOCOL *) Fibre;
1283 }
1284
1285 /**
1286 Converts a text device path node to 1394 device path structure.
1287
1288 @param TextDeviceNode The input Text device path node.
1289
1290 @return A pointer to the newly-created 1394 device path structure.
1291
1292 **/
1293 EFI_DEVICE_PATH_PROTOCOL *
1294 DevPathFromText1394 (
1295 IN CHAR16 *TextDeviceNode
1296 )
1297 {
1298 CHAR16 *GuidStr;
1299 F1394_DEVICE_PATH *F1394DevPath;
1300
1301 GuidStr = GetNextParamStr (&TextDeviceNode);
1302 F1394DevPath = (F1394_DEVICE_PATH *) CreateDeviceNode (
1303 MESSAGING_DEVICE_PATH,
1304 MSG_1394_DP,
1305 (UINT16) sizeof (F1394_DEVICE_PATH)
1306 );
1307
1308 F1394DevPath->Reserved = 0;
1309 Xtoi64 (GuidStr, &F1394DevPath->Guid);
1310
1311 return (EFI_DEVICE_PATH_PROTOCOL *) F1394DevPath;
1312 }
1313
1314 /**
1315 Converts a text device path node to USB device path structure.
1316
1317 @param TextDeviceNode The input Text device path node.
1318
1319 @return A pointer to the newly-created USB device path structure.
1320
1321 **/
1322 EFI_DEVICE_PATH_PROTOCOL *
1323 DevPathFromTextUsb (
1324 IN CHAR16 *TextDeviceNode
1325 )
1326 {
1327 CHAR16 *PortStr;
1328 CHAR16 *InterfaceStr;
1329 USB_DEVICE_PATH *Usb;
1330
1331 PortStr = GetNextParamStr (&TextDeviceNode);
1332 InterfaceStr = GetNextParamStr (&TextDeviceNode);
1333 Usb = (USB_DEVICE_PATH *) CreateDeviceNode (
1334 MESSAGING_DEVICE_PATH,
1335 MSG_USB_DP,
1336 (UINT16) sizeof (USB_DEVICE_PATH)
1337 );
1338
1339 Usb->ParentPortNumber = (UINT8) Strtoi (PortStr);
1340 Usb->InterfaceNumber = (UINT8) Strtoi (InterfaceStr);
1341
1342 return (EFI_DEVICE_PATH_PROTOCOL *) Usb;
1343 }
1344
1345 /**
1346 Converts a text device path node to I20 device path structure.
1347
1348 @param TextDeviceNode The input Text device path node.
1349
1350 @return A pointer to the newly-created I20 device path structure.
1351
1352 **/
1353 EFI_DEVICE_PATH_PROTOCOL *
1354 DevPathFromTextI2O (
1355 IN CHAR16 *TextDeviceNode
1356 )
1357 {
1358 CHAR16 *TIDStr;
1359 I2O_DEVICE_PATH *I2ODevPath;
1360
1361 TIDStr = GetNextParamStr (&TextDeviceNode);
1362 I2ODevPath = (I2O_DEVICE_PATH *) CreateDeviceNode (
1363 MESSAGING_DEVICE_PATH,
1364 MSG_I2O_DP,
1365 (UINT16) sizeof (I2O_DEVICE_PATH)
1366 );
1367
1368 I2ODevPath->Tid = (UINT32) Strtoi (TIDStr);
1369
1370 return (EFI_DEVICE_PATH_PROTOCOL *) I2ODevPath;
1371 }
1372
1373 /**
1374 Converts a text device path node to Infini Band device path structure.
1375
1376 @param TextDeviceNode The input Text device path node.
1377
1378 @return A pointer to the newly-created Infini Band device path structure.
1379
1380 **/
1381 EFI_DEVICE_PATH_PROTOCOL *
1382 DevPathFromTextInfiniband (
1383 IN CHAR16 *TextDeviceNode
1384 )
1385 {
1386 CHAR16 *FlagsStr;
1387 CHAR16 *GuidStr;
1388 CHAR16 *SidStr;
1389 CHAR16 *TidStr;
1390 CHAR16 *DidStr;
1391 EFI_GUID PortGid;
1392 INFINIBAND_DEVICE_PATH *InfiniBand;
1393
1394 FlagsStr = GetNextParamStr (&TextDeviceNode);
1395 GuidStr = GetNextParamStr (&TextDeviceNode);
1396 SidStr = GetNextParamStr (&TextDeviceNode);
1397 TidStr = GetNextParamStr (&TextDeviceNode);
1398 DidStr = GetNextParamStr (&TextDeviceNode);
1399 InfiniBand = (INFINIBAND_DEVICE_PATH *) CreateDeviceNode (
1400 MESSAGING_DEVICE_PATH,
1401 MSG_INFINIBAND_DP,
1402 (UINT16) sizeof (INFINIBAND_DEVICE_PATH)
1403 );
1404
1405 InfiniBand->ResourceFlags = (UINT32) Strtoi (FlagsStr);
1406 StrToGuid (GuidStr, &PortGid);
1407 CopyMem (InfiniBand->PortGid, &PortGid, sizeof (EFI_GUID));
1408 Strtoi64 (SidStr, &InfiniBand->ServiceId);
1409 Strtoi64 (TidStr, &InfiniBand->TargetPortId);
1410 Strtoi64 (DidStr, &InfiniBand->DeviceId);
1411
1412 return (EFI_DEVICE_PATH_PROTOCOL *) InfiniBand;
1413 }
1414
1415 /**
1416 Converts a text device path node to Vendor-Defined Messaging device path structure.
1417
1418 @param TextDeviceNode The input Text device path node.
1419
1420 @return A pointer to the newly-created Vendor-Defined Messaging device path structure.
1421
1422 **/
1423 EFI_DEVICE_PATH_PROTOCOL *
1424 DevPathFromTextVenMsg (
1425 IN CHAR16 *TextDeviceNode
1426 )
1427 {
1428 return ConvertFromTextVendor (
1429 TextDeviceNode,
1430 MESSAGING_DEVICE_PATH,
1431 MSG_VENDOR_DP
1432 );
1433 }
1434
1435 /**
1436 Converts a text device path node to Vendor defined PC-ANSI device path structure.
1437
1438 @param TextDeviceNode The input Text device path node.
1439
1440 @return A pointer to the newly-created Vendor defined PC-ANSI device path structure.
1441
1442 **/
1443 EFI_DEVICE_PATH_PROTOCOL *
1444 DevPathFromTextVenPcAnsi (
1445 IN CHAR16 *TextDeviceNode
1446 )
1447 {
1448 VENDOR_DEVICE_PATH *Vendor;
1449
1450 Vendor = (VENDOR_DEVICE_PATH *) CreateDeviceNode (
1451 MESSAGING_DEVICE_PATH,
1452 MSG_VENDOR_DP,
1453 (UINT16) sizeof (VENDOR_DEVICE_PATH));
1454 CopyGuid (&Vendor->Guid, &gEfiPcAnsiGuid);
1455
1456 return (EFI_DEVICE_PATH_PROTOCOL *) Vendor;
1457 }
1458
1459 /**
1460 Converts a text device path node to Vendor defined VT100 device path structure.
1461
1462 @param TextDeviceNode The input Text device path node.
1463
1464 @return A pointer to the newly-created Vendor defined VT100 device path structure.
1465
1466 **/
1467 EFI_DEVICE_PATH_PROTOCOL *
1468 DevPathFromTextVenVt100 (
1469 IN CHAR16 *TextDeviceNode
1470 )
1471 {
1472 VENDOR_DEVICE_PATH *Vendor;
1473
1474 Vendor = (VENDOR_DEVICE_PATH *) CreateDeviceNode (
1475 MESSAGING_DEVICE_PATH,
1476 MSG_VENDOR_DP,
1477 (UINT16) sizeof (VENDOR_DEVICE_PATH));
1478 CopyGuid (&Vendor->Guid, &gEfiVT100Guid);
1479
1480 return (EFI_DEVICE_PATH_PROTOCOL *) Vendor;
1481 }
1482
1483 /**
1484 Converts a text device path node to Vendor defined VT100 Plus device path structure.
1485
1486 @param TextDeviceNode The input Text device path node.
1487
1488 @return A pointer to the newly-created Vendor defined VT100 Plus device path structure.
1489
1490 **/
1491 EFI_DEVICE_PATH_PROTOCOL *
1492 DevPathFromTextVenVt100Plus (
1493 IN CHAR16 *TextDeviceNode
1494 )
1495 {
1496 VENDOR_DEVICE_PATH *Vendor;
1497
1498 Vendor = (VENDOR_DEVICE_PATH *) CreateDeviceNode (
1499 MESSAGING_DEVICE_PATH,
1500 MSG_VENDOR_DP,
1501 (UINT16) sizeof (VENDOR_DEVICE_PATH));
1502 CopyGuid (&Vendor->Guid, &gEfiVT100PlusGuid);
1503
1504 return (EFI_DEVICE_PATH_PROTOCOL *) Vendor;
1505 }
1506
1507 /**
1508 Converts a text device path node to Vendor defined UTF8 device path structure.
1509
1510 @param TextDeviceNode The input Text device path node.
1511
1512 @return A pointer to the newly-created Vendor defined UTF8 device path structure.
1513
1514 **/
1515 EFI_DEVICE_PATH_PROTOCOL *
1516 DevPathFromTextVenUtf8 (
1517 IN CHAR16 *TextDeviceNode
1518 )
1519 {
1520 VENDOR_DEVICE_PATH *Vendor;
1521
1522 Vendor = (VENDOR_DEVICE_PATH *) CreateDeviceNode (
1523 MESSAGING_DEVICE_PATH,
1524 MSG_VENDOR_DP,
1525 (UINT16) sizeof (VENDOR_DEVICE_PATH));
1526 CopyGuid (&Vendor->Guid, &gEfiVTUTF8Guid);
1527
1528 return (EFI_DEVICE_PATH_PROTOCOL *) Vendor;
1529 }
1530
1531 /**
1532 Converts a text device path node to UART Flow Control device path structure.
1533
1534 @param TextDeviceNode The input Text device path node.
1535
1536 @return A pointer to the newly-created UART Flow Control device path structure.
1537
1538 **/
1539 EFI_DEVICE_PATH_PROTOCOL *
1540 DevPathFromTextUartFlowCtrl (
1541 IN CHAR16 *TextDeviceNode
1542 )
1543 {
1544 CHAR16 *ValueStr;
1545 UART_FLOW_CONTROL_DEVICE_PATH *UartFlowControl;
1546
1547 ValueStr = GetNextParamStr (&TextDeviceNode);
1548 UartFlowControl = (UART_FLOW_CONTROL_DEVICE_PATH *) CreateDeviceNode (
1549 MESSAGING_DEVICE_PATH,
1550 MSG_VENDOR_DP,
1551 (UINT16) sizeof (UART_FLOW_CONTROL_DEVICE_PATH)
1552 );
1553
1554 CopyGuid (&UartFlowControl->Guid, &gEfiUartDevicePathGuid);
1555 if (StrCmp (ValueStr, L"XonXoff") == 0) {
1556 UartFlowControl->FlowControlMap = 2;
1557 } else if (StrCmp (ValueStr, L"Hardware") == 0) {
1558 UartFlowControl->FlowControlMap = 1;
1559 } else {
1560 UartFlowControl->FlowControlMap = 0;
1561 }
1562
1563 return (EFI_DEVICE_PATH_PROTOCOL *) UartFlowControl;
1564 }
1565
1566 /**
1567 Converts a text device path node to Serial Attached SCSI device path structure.
1568
1569 @param TextDeviceNode The input Text device path node.
1570
1571 @return A pointer to the newly-created Serial Attached SCSI device path structure.
1572
1573 **/
1574 EFI_DEVICE_PATH_PROTOCOL *
1575 DevPathFromTextSAS (
1576 IN CHAR16 *TextDeviceNode
1577 )
1578 {
1579 CHAR16 *AddressStr;
1580 CHAR16 *LunStr;
1581 CHAR16 *RTPStr;
1582 CHAR16 *SASSATAStr;
1583 CHAR16 *LocationStr;
1584 CHAR16 *ConnectStr;
1585 CHAR16 *DriveBayStr;
1586 CHAR16 *ReservedStr;
1587 UINT16 Info;
1588 SAS_DEVICE_PATH *Sas;
1589
1590 AddressStr = GetNextParamStr (&TextDeviceNode);
1591 LunStr = GetNextParamStr (&TextDeviceNode);
1592 RTPStr = GetNextParamStr (&TextDeviceNode);
1593 SASSATAStr = GetNextParamStr (&TextDeviceNode);
1594 LocationStr = GetNextParamStr (&TextDeviceNode);
1595 ConnectStr = GetNextParamStr (&TextDeviceNode);
1596 DriveBayStr = GetNextParamStr (&TextDeviceNode);
1597 ReservedStr = GetNextParamStr (&TextDeviceNode);
1598 Info = 0x0000;
1599 Sas = (SAS_DEVICE_PATH *) CreateDeviceNode (
1600 MESSAGING_DEVICE_PATH,
1601 MSG_VENDOR_DP,
1602 (UINT16) sizeof (SAS_DEVICE_PATH)
1603 );
1604
1605 CopyGuid (&Sas->Guid, &gEfiSasDevicePathGuid);
1606 Strtoi64 (AddressStr, &Sas->SasAddress);
1607 Strtoi64 (LunStr, &Sas->Lun);
1608 Sas->RelativeTargetPort = (UINT16) Strtoi (RTPStr);
1609 if (StrCmp (SASSATAStr, L"NoTopology") != 0) {
1610 if (StrCmp (DriveBayStr, L"0") == 0) {
1611 Info |= 0x0001;
1612 } else {
1613 Info |= 0x0002;
1614 Info = (UINT16) (Info | (Strtoi (DriveBayStr) << 8));
1615 }
1616
1617 if (StrCmp (SASSATAStr, L"SATA") == 0) {
1618 Info |= 0x0010;
1619 }
1620
1621 if (StrCmp (LocationStr, L"External") == 0) {
1622 Info |= 0x0020;
1623 }
1624
1625 if (StrCmp (ConnectStr, L"Expanded") == 0) {
1626 Info |= 0x0040;
1627 }
1628 }
1629
1630 Sas->DeviceTopology = Info;
1631 Sas->Reserved = (UINT32) Strtoi (ReservedStr);
1632
1633 return (EFI_DEVICE_PATH_PROTOCOL *) Sas;
1634 }
1635
1636 /**
1637 Converts a text device path node to Debug Port device path structure.
1638
1639 @param TextDeviceNode The input Text device path node.
1640
1641 @return A pointer to the newly-created Debug Port device path structure.
1642
1643 **/
1644 EFI_DEVICE_PATH_PROTOCOL *
1645 DevPathFromTextDebugPort (
1646 IN CHAR16 *TextDeviceNode
1647 )
1648 {
1649 VENDOR_DEFINED_MESSAGING_DEVICE_PATH *Vend;
1650
1651 Vend = (VENDOR_DEFINED_MESSAGING_DEVICE_PATH *) CreateDeviceNode (
1652 MESSAGING_DEVICE_PATH,
1653 MSG_VENDOR_DP,
1654 (UINT16) sizeof (VENDOR_DEFINED_MESSAGING_DEVICE_PATH)
1655 );
1656
1657 CopyGuid (&Vend->Guid, &gEfiDebugPortProtocolGuid);
1658
1659 return (EFI_DEVICE_PATH_PROTOCOL *) Vend;
1660 }
1661
1662 /**
1663 Converts a text device path node to MAC device path structure.
1664
1665 @param TextDeviceNode The input Text device path node.
1666
1667 @return A pointer to the newly-created MAC device path structure.
1668
1669 **/
1670 EFI_DEVICE_PATH_PROTOCOL *
1671 DevPathFromTextMAC (
1672 IN CHAR16 *TextDeviceNode
1673 )
1674 {
1675 CHAR16 *AddressStr;
1676 CHAR16 *IfTypeStr;
1677 UINTN Length;
1678 MAC_ADDR_DEVICE_PATH *MACDevPath;
1679
1680 AddressStr = GetNextParamStr (&TextDeviceNode);
1681 IfTypeStr = GetNextParamStr (&TextDeviceNode);
1682 MACDevPath = (MAC_ADDR_DEVICE_PATH *) CreateDeviceNode (
1683 MESSAGING_DEVICE_PATH,
1684 MSG_MAC_ADDR_DP,
1685 (UINT16) sizeof (MAC_ADDR_DEVICE_PATH)
1686 );
1687
1688 MACDevPath->IfType = (UINT8) Strtoi (IfTypeStr);
1689
1690 Length = sizeof (EFI_MAC_ADDRESS);
1691 StrToBuf (&MACDevPath->MacAddress.Addr[0], Length, AddressStr);
1692
1693 return (EFI_DEVICE_PATH_PROTOCOL *) MACDevPath;
1694 }
1695
1696
1697 /**
1698 Converts a text format to the network protocol ID.
1699
1700 @param Text String of protocol field.
1701
1702 @return Network protocol ID .
1703
1704 **/
1705 UINTN
1706 NetworkProtocolFromText (
1707 IN CHAR16 *Text
1708 )
1709 {
1710 if (StrCmp (Text, L"UDP") == 0) {
1711 return RFC_1700_UDP_PROTOCOL;
1712 }
1713
1714 if (StrCmp (Text, L"TCP") == 0) {
1715 return RFC_1700_TCP_PROTOCOL;
1716 }
1717
1718 return Strtoi (Text);
1719 }
1720
1721
1722 /**
1723 Converts a text device path node to IPV4 device path structure.
1724
1725 @param TextDeviceNode The input Text device path node.
1726
1727 @return A pointer to the newly-created IPV4 device path structure.
1728
1729 **/
1730 EFI_DEVICE_PATH_PROTOCOL *
1731 DevPathFromTextIPv4 (
1732 IN CHAR16 *TextDeviceNode
1733 )
1734 {
1735 CHAR16 *RemoteIPStr;
1736 CHAR16 *ProtocolStr;
1737 CHAR16 *TypeStr;
1738 CHAR16 *LocalIPStr;
1739 IPv4_DEVICE_PATH *IPv4;
1740
1741 RemoteIPStr = GetNextParamStr (&TextDeviceNode);
1742 ProtocolStr = GetNextParamStr (&TextDeviceNode);
1743 TypeStr = GetNextParamStr (&TextDeviceNode);
1744 LocalIPStr = GetNextParamStr (&TextDeviceNode);
1745 IPv4 = (IPv4_DEVICE_PATH *) CreateDeviceNode (
1746 MESSAGING_DEVICE_PATH,
1747 MSG_IPv4_DP,
1748 (UINT16) sizeof (IPv4_DEVICE_PATH)
1749 );
1750
1751 StrToIPv4Addr (&RemoteIPStr, &IPv4->RemoteIpAddress);
1752 IPv4->Protocol = (UINT16) NetworkProtocolFromText (ProtocolStr);
1753 if (StrCmp (TypeStr, L"Static") == 0) {
1754 IPv4->StaticIpAddress = TRUE;
1755 } else {
1756 IPv4->StaticIpAddress = FALSE;
1757 }
1758
1759 StrToIPv4Addr (&LocalIPStr, &IPv4->LocalIpAddress);
1760
1761 IPv4->LocalPort = 0;
1762 IPv4->RemotePort = 0;
1763
1764 return (EFI_DEVICE_PATH_PROTOCOL *) IPv4;
1765 }
1766
1767 /**
1768 Converts a text device path node to IPV6 device path structure.
1769
1770 @param TextDeviceNode The input Text device path node.
1771
1772 @return A pointer to the newly-created IPV6 device path structure.
1773
1774 **/
1775 EFI_DEVICE_PATH_PROTOCOL *
1776 DevPathFromTextIPv6 (
1777 IN CHAR16 *TextDeviceNode
1778 )
1779 {
1780 CHAR16 *RemoteIPStr;
1781 CHAR16 *ProtocolStr;
1782 CHAR16 *TypeStr;
1783 CHAR16 *LocalIPStr;
1784 IPv6_DEVICE_PATH *IPv6;
1785
1786 RemoteIPStr = GetNextParamStr (&TextDeviceNode);
1787 ProtocolStr = GetNextParamStr (&TextDeviceNode);
1788 TypeStr = GetNextParamStr (&TextDeviceNode);
1789 LocalIPStr = GetNextParamStr (&TextDeviceNode);
1790 IPv6 = (IPv6_DEVICE_PATH *) CreateDeviceNode (
1791 MESSAGING_DEVICE_PATH,
1792 MSG_IPv6_DP,
1793 (UINT16) sizeof (IPv6_DEVICE_PATH)
1794 );
1795
1796 StrToIPv6Addr (&RemoteIPStr, &IPv6->RemoteIpAddress);
1797 IPv6->Protocol = (UINT16) NetworkProtocolFromText (ProtocolStr);
1798 if (StrCmp (TypeStr, L"Static") == 0) {
1799 IPv6->StaticIpAddress = TRUE;
1800 } else {
1801 IPv6->StaticIpAddress = FALSE;
1802 }
1803
1804 StrToIPv6Addr (&LocalIPStr, &IPv6->LocalIpAddress);
1805
1806 IPv6->LocalPort = 0;
1807 IPv6->RemotePort = 0;
1808
1809 return (EFI_DEVICE_PATH_PROTOCOL *) IPv6;
1810 }
1811
1812 /**
1813 Converts a text device path node to UART device path structure.
1814
1815 @param TextDeviceNode The input Text device path node.
1816
1817 @return A pointer to the newly-created UART device path structure.
1818
1819 **/
1820 EFI_DEVICE_PATH_PROTOCOL *
1821 DevPathFromTextUart (
1822 IN CHAR16 *TextDeviceNode
1823 )
1824 {
1825 CHAR16 *BaudStr;
1826 CHAR16 *DataBitsStr;
1827 CHAR16 *ParityStr;
1828 CHAR16 *StopBitsStr;
1829 UART_DEVICE_PATH *Uart;
1830
1831 BaudStr = GetNextParamStr (&TextDeviceNode);
1832 DataBitsStr = GetNextParamStr (&TextDeviceNode);
1833 ParityStr = GetNextParamStr (&TextDeviceNode);
1834 StopBitsStr = GetNextParamStr (&TextDeviceNode);
1835 Uart = (UART_DEVICE_PATH *) CreateDeviceNode (
1836 MESSAGING_DEVICE_PATH,
1837 MSG_UART_DP,
1838 (UINT16) sizeof (UART_DEVICE_PATH)
1839 );
1840
1841 Uart->BaudRate = (StrCmp (BaudStr, L"DEFAULT") == 0) ? 115200 : Dtoi (BaudStr);
1842 Uart->DataBits = (UINT8) ((StrCmp (DataBitsStr, L"DEFAULT") == 0) ? 8 : Dtoi (DataBitsStr));
1843 switch (*ParityStr) {
1844 case L'D':
1845 Uart->Parity = 0;
1846 break;
1847
1848 case L'N':
1849 Uart->Parity = 1;
1850 break;
1851
1852 case L'E':
1853 Uart->Parity = 2;
1854 break;
1855
1856 case L'O':
1857 Uart->Parity = 3;
1858 break;
1859
1860 case L'M':
1861 Uart->Parity = 4;
1862 break;
1863
1864 case L'S':
1865 Uart->Parity = 5;
1866
1867 default:
1868 Uart->Parity = 0xff;
1869 }
1870
1871 if (StrCmp (StopBitsStr, L"D") == 0) {
1872 Uart->StopBits = (UINT8) 0;
1873 } else if (StrCmp (StopBitsStr, L"1") == 0) {
1874 Uart->StopBits = (UINT8) 1;
1875 } else if (StrCmp (StopBitsStr, L"1.5") == 0) {
1876 Uart->StopBits = (UINT8) 2;
1877 } else if (StrCmp (StopBitsStr, L"2") == 0) {
1878 Uart->StopBits = (UINT8) 3;
1879 } else {
1880 Uart->StopBits = 0xff;
1881 }
1882
1883 return (EFI_DEVICE_PATH_PROTOCOL *) Uart;
1884 }
1885
1886 /**
1887 Converts a text device path node to USB class device path structure.
1888
1889 @param TextDeviceNode The input Text device path node.
1890 @param UsbClassText A pointer to USB_CLASS_TEXT structure to be integrated to USB Class Text.
1891
1892 @return A pointer to the newly-created USB class device path structure.
1893
1894 **/
1895 EFI_DEVICE_PATH_PROTOCOL *
1896 ConvertFromTextUsbClass (
1897 IN CHAR16 *TextDeviceNode,
1898 IN USB_CLASS_TEXT *UsbClassText
1899 )
1900 {
1901 CHAR16 *VIDStr;
1902 CHAR16 *PIDStr;
1903 CHAR16 *ClassStr;
1904 CHAR16 *SubClassStr;
1905 CHAR16 *ProtocolStr;
1906 USB_CLASS_DEVICE_PATH *UsbClass;
1907
1908 UsbClass = (USB_CLASS_DEVICE_PATH *) CreateDeviceNode (
1909 MESSAGING_DEVICE_PATH,
1910 MSG_USB_CLASS_DP,
1911 (UINT16) sizeof (USB_CLASS_DEVICE_PATH)
1912 );
1913
1914 VIDStr = GetNextParamStr (&TextDeviceNode);
1915 PIDStr = GetNextParamStr (&TextDeviceNode);
1916 if (UsbClassText->ClassExist) {
1917 ClassStr = GetNextParamStr (&TextDeviceNode);
1918 UsbClass->DeviceClass = (UINT8) Strtoi (ClassStr);
1919 } else {
1920 UsbClass->DeviceClass = UsbClassText->Class;
1921 }
1922 if (UsbClassText->SubClassExist) {
1923 SubClassStr = GetNextParamStr (&TextDeviceNode);
1924 UsbClass->DeviceSubClass = (UINT8) Strtoi (SubClassStr);
1925 } else {
1926 UsbClass->DeviceSubClass = UsbClassText->SubClass;
1927 }
1928
1929 ProtocolStr = GetNextParamStr (&TextDeviceNode);
1930
1931 UsbClass->VendorId = (UINT16) Strtoi (VIDStr);
1932 UsbClass->ProductId = (UINT16) Strtoi (PIDStr);
1933 UsbClass->DeviceProtocol = (UINT8) Strtoi (ProtocolStr);
1934
1935 return (EFI_DEVICE_PATH_PROTOCOL *) UsbClass;
1936 }
1937
1938
1939 /**
1940 Converts a text device path node to USB class device path structure.
1941
1942 @param TextDeviceNode The input Text device path node.
1943
1944 @return A pointer to the newly-created USB class device path structure.
1945
1946 **/
1947 EFI_DEVICE_PATH_PROTOCOL *
1948 DevPathFromTextUsbClass (
1949 IN CHAR16 *TextDeviceNode
1950 )
1951 {
1952 USB_CLASS_TEXT UsbClassText;
1953
1954 UsbClassText.ClassExist = TRUE;
1955 UsbClassText.SubClassExist = TRUE;
1956
1957 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1958 }
1959
1960 /**
1961 Converts a text device path node to USB audio device path structure.
1962
1963 @param TextDeviceNode The input Text device path node.
1964
1965 @return A pointer to the newly-created USB audio device path structure.
1966
1967 **/
1968 EFI_DEVICE_PATH_PROTOCOL *
1969 DevPathFromTextUsbAudio (
1970 IN CHAR16 *TextDeviceNode
1971 )
1972 {
1973 USB_CLASS_TEXT UsbClassText;
1974
1975 UsbClassText.ClassExist = FALSE;
1976 UsbClassText.Class = USB_CLASS_AUDIO;
1977 UsbClassText.SubClassExist = TRUE;
1978
1979 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1980 }
1981
1982 /**
1983 Converts a text device path node to USB CDC Control device path structure.
1984
1985 @param TextDeviceNode The input Text device path node.
1986
1987 @return A pointer to the newly-created USB CDC Control device path structure.
1988
1989 **/
1990 EFI_DEVICE_PATH_PROTOCOL *
1991 DevPathFromTextUsbCDCControl (
1992 IN CHAR16 *TextDeviceNode
1993 )
1994 {
1995 USB_CLASS_TEXT UsbClassText;
1996
1997 UsbClassText.ClassExist = FALSE;
1998 UsbClassText.Class = USB_CLASS_CDCCONTROL;
1999 UsbClassText.SubClassExist = TRUE;
2000
2001 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2002 }
2003
2004 /**
2005 Converts a text device path node to USB HID device path structure.
2006
2007 @param TextDeviceNode The input Text device path node.
2008
2009 @return A pointer to the newly-created USB HID device path structure.
2010
2011 **/
2012 EFI_DEVICE_PATH_PROTOCOL *
2013 DevPathFromTextUsbHID (
2014 IN CHAR16 *TextDeviceNode
2015 )
2016 {
2017 USB_CLASS_TEXT UsbClassText;
2018
2019 UsbClassText.ClassExist = FALSE;
2020 UsbClassText.Class = USB_CLASS_HID;
2021 UsbClassText.SubClassExist = TRUE;
2022
2023 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2024 }
2025
2026 /**
2027 Converts a text device path node to USB Image device path structure.
2028
2029 @param TextDeviceNode The input Text device path node.
2030
2031 @return A pointer to the newly-created USB Image device path structure.
2032
2033 **/
2034 EFI_DEVICE_PATH_PROTOCOL *
2035 DevPathFromTextUsbImage (
2036 IN CHAR16 *TextDeviceNode
2037 )
2038 {
2039 USB_CLASS_TEXT UsbClassText;
2040
2041 UsbClassText.ClassExist = FALSE;
2042 UsbClassText.Class = USB_CLASS_IMAGE;
2043 UsbClassText.SubClassExist = TRUE;
2044
2045 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2046 }
2047
2048 /**
2049 Converts a text device path node to USB Print device path structure.
2050
2051 @param TextDeviceNode The input Text device path node.
2052
2053 @return A pointer to the newly-created USB Print device path structure.
2054
2055 **/
2056 EFI_DEVICE_PATH_PROTOCOL *
2057 DevPathFromTextUsbPrinter (
2058 IN CHAR16 *TextDeviceNode
2059 )
2060 {
2061 USB_CLASS_TEXT UsbClassText;
2062
2063 UsbClassText.ClassExist = FALSE;
2064 UsbClassText.Class = USB_CLASS_PRINTER;
2065 UsbClassText.SubClassExist = TRUE;
2066
2067 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2068 }
2069
2070 /**
2071 Converts a text device path node to USB mass storage device path structure.
2072
2073 @param TextDeviceNode The input Text device path node.
2074
2075 @return A pointer to the newly-created USB mass storage device path structure.
2076
2077 **/
2078 EFI_DEVICE_PATH_PROTOCOL *
2079 DevPathFromTextUsbMassStorage (
2080 IN CHAR16 *TextDeviceNode
2081 )
2082 {
2083 USB_CLASS_TEXT UsbClassText;
2084
2085 UsbClassText.ClassExist = FALSE;
2086 UsbClassText.Class = USB_CLASS_MASS_STORAGE;
2087 UsbClassText.SubClassExist = TRUE;
2088
2089 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2090 }
2091
2092 /**
2093 Converts a text device path node to USB HUB device path structure.
2094
2095 @param TextDeviceNode The input Text device path node.
2096
2097 @return A pointer to the newly-created USB HUB device path structure.
2098
2099 **/
2100 EFI_DEVICE_PATH_PROTOCOL *
2101 DevPathFromTextUsbHub (
2102 IN CHAR16 *TextDeviceNode
2103 )
2104 {
2105 USB_CLASS_TEXT UsbClassText;
2106
2107 UsbClassText.ClassExist = FALSE;
2108 UsbClassText.Class = USB_CLASS_HUB;
2109 UsbClassText.SubClassExist = TRUE;
2110
2111 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2112 }
2113
2114 /**
2115 Converts a text device path node to USB CDC data device path structure.
2116
2117 @param TextDeviceNode The input Text device path node.
2118
2119 @return A pointer to the newly-created USB CDC data device path structure.
2120
2121 **/
2122 EFI_DEVICE_PATH_PROTOCOL *
2123 DevPathFromTextUsbCDCData (
2124 IN CHAR16 *TextDeviceNode
2125 )
2126 {
2127 USB_CLASS_TEXT UsbClassText;
2128
2129 UsbClassText.ClassExist = FALSE;
2130 UsbClassText.Class = USB_CLASS_CDCDATA;
2131 UsbClassText.SubClassExist = TRUE;
2132
2133 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2134 }
2135
2136 /**
2137 Converts a text device path node to USB smart card device path structure.
2138
2139 @param TextDeviceNode The input Text device path node.
2140
2141 @return A pointer to the newly-created USB smart card device path structure.
2142
2143 **/
2144 EFI_DEVICE_PATH_PROTOCOL *
2145 DevPathFromTextUsbSmartCard (
2146 IN CHAR16 *TextDeviceNode
2147 )
2148 {
2149 USB_CLASS_TEXT UsbClassText;
2150
2151 UsbClassText.ClassExist = FALSE;
2152 UsbClassText.Class = USB_CLASS_SMART_CARD;
2153 UsbClassText.SubClassExist = TRUE;
2154
2155 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2156 }
2157
2158 /**
2159 Converts a text device path node to USB video device path structure.
2160
2161 @param TextDeviceNode The input Text device path node.
2162
2163 @return A pointer to the newly-created USB video device path structure.
2164
2165 **/
2166 EFI_DEVICE_PATH_PROTOCOL *
2167 DevPathFromTextUsbVideo (
2168 IN CHAR16 *TextDeviceNode
2169 )
2170 {
2171 USB_CLASS_TEXT UsbClassText;
2172
2173 UsbClassText.ClassExist = FALSE;
2174 UsbClassText.Class = USB_CLASS_VIDEO;
2175 UsbClassText.SubClassExist = TRUE;
2176
2177 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2178 }
2179
2180 /**
2181 Converts a text device path node to USB diagnostic device path structure.
2182
2183 @param TextDeviceNode The input Text device path node.
2184
2185 @return A pointer to the newly-created USB diagnostic device path structure.
2186
2187 **/
2188 EFI_DEVICE_PATH_PROTOCOL *
2189 DevPathFromTextUsbDiagnostic (
2190 IN CHAR16 *TextDeviceNode
2191 )
2192 {
2193 USB_CLASS_TEXT UsbClassText;
2194
2195 UsbClassText.ClassExist = FALSE;
2196 UsbClassText.Class = USB_CLASS_DIAGNOSTIC;
2197 UsbClassText.SubClassExist = TRUE;
2198
2199 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2200 }
2201
2202 /**
2203 Converts a text device path node to USB wireless device path structure.
2204
2205 @param TextDeviceNode The input Text device path node.
2206
2207 @return A pointer to the newly-created USB wireless device path structure.
2208
2209 **/
2210 EFI_DEVICE_PATH_PROTOCOL *
2211 DevPathFromTextUsbWireless (
2212 IN CHAR16 *TextDeviceNode
2213 )
2214 {
2215 USB_CLASS_TEXT UsbClassText;
2216
2217 UsbClassText.ClassExist = FALSE;
2218 UsbClassText.Class = USB_CLASS_WIRELESS;
2219 UsbClassText.SubClassExist = TRUE;
2220
2221 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2222 }
2223
2224 /**
2225 Converts a text device path node to USB device firmware update device path structure.
2226
2227 @param TextDeviceNode The input Text device path node.
2228
2229 @return A pointer to the newly-created USB device firmware update device path structure.
2230
2231 **/
2232 EFI_DEVICE_PATH_PROTOCOL *
2233 DevPathFromTextUsbDeviceFirmwareUpdate (
2234 IN CHAR16 *TextDeviceNode
2235 )
2236 {
2237 USB_CLASS_TEXT UsbClassText;
2238
2239 UsbClassText.ClassExist = FALSE;
2240 UsbClassText.Class = USB_CLASS_RESERVE;
2241 UsbClassText.SubClassExist = FALSE;
2242 UsbClassText.SubClass = USB_SUBCLASS_FW_UPDATE;
2243
2244 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2245 }
2246
2247 /**
2248 Converts a text device path node to USB IRDA bridge device path structure.
2249
2250 @param TextDeviceNode The input Text device path node.
2251
2252 @return A pointer to the newly-created USB IRDA bridge device path structure.
2253
2254 **/
2255 EFI_DEVICE_PATH_PROTOCOL *
2256 DevPathFromTextUsbIrdaBridge (
2257 IN CHAR16 *TextDeviceNode
2258 )
2259 {
2260 USB_CLASS_TEXT UsbClassText;
2261
2262 UsbClassText.ClassExist = FALSE;
2263 UsbClassText.Class = USB_CLASS_RESERVE;
2264 UsbClassText.SubClassExist = FALSE;
2265 UsbClassText.SubClass = USB_SUBCLASS_IRDA_BRIDGE;
2266
2267 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2268 }
2269
2270 /**
2271 Converts a text device path node to USB text and measurement device path structure.
2272
2273 @param TextDeviceNode The input Text device path node.
2274
2275 @return A pointer to the newly-created USB text and measurement device path structure.
2276
2277 **/
2278 EFI_DEVICE_PATH_PROTOCOL *
2279 DevPathFromTextUsbTestAndMeasurement (
2280 IN CHAR16 *TextDeviceNode
2281 )
2282 {
2283 USB_CLASS_TEXT UsbClassText;
2284
2285 UsbClassText.ClassExist = FALSE;
2286 UsbClassText.Class = USB_CLASS_RESERVE;
2287 UsbClassText.SubClassExist = FALSE;
2288 UsbClassText.SubClass = USB_SUBCLASS_TEST;
2289
2290 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
2291 }
2292
2293 /**
2294 Converts a text device path node to USB WWID device path structure.
2295
2296 @param TextDeviceNode The input Text device path node.
2297
2298 @return A pointer to the newly-created USB WWID device path structure.
2299
2300 **/
2301 EFI_DEVICE_PATH_PROTOCOL *
2302 DevPathFromTextUsbWwid (
2303 IN CHAR16 *TextDeviceNode
2304 )
2305 {
2306 CHAR16 *VIDStr;
2307 CHAR16 *PIDStr;
2308 CHAR16 *InterfaceNumStr;
2309 CHAR16 *SerialNumberStr;
2310 USB_WWID_DEVICE_PATH *UsbWwid;
2311
2312 VIDStr = GetNextParamStr (&TextDeviceNode);
2313 PIDStr = GetNextParamStr (&TextDeviceNode);
2314 InterfaceNumStr = GetNextParamStr (&TextDeviceNode);
2315 SerialNumberStr = GetNextParamStr (&TextDeviceNode);
2316 UsbWwid = (USB_WWID_DEVICE_PATH *) CreateDeviceNode (
2317 MESSAGING_DEVICE_PATH,
2318 MSG_USB_WWID_DP,
2319 (UINT16) (sizeof (USB_WWID_DEVICE_PATH) + StrSize (SerialNumberStr))
2320 );
2321
2322 UsbWwid->VendorId = (UINT16) Strtoi (VIDStr);
2323 UsbWwid->ProductId = (UINT16) Strtoi (PIDStr);
2324 UsbWwid->InterfaceNumber = (UINT16) Strtoi (InterfaceNumStr);
2325 StrCpy ((CHAR16 *) ((UINT8 *) UsbWwid + sizeof (USB_WWID_DEVICE_PATH)), SerialNumberStr);
2326
2327 return (EFI_DEVICE_PATH_PROTOCOL *) UsbWwid;
2328 }
2329
2330 /**
2331 Converts a text device path node to Logic Unit device path structure.
2332
2333 @param TextDeviceNode The input Text device path node.
2334
2335 @return A pointer to the newly-created Logic Unit device path structure.
2336
2337 **/
2338 EFI_DEVICE_PATH_PROTOCOL *
2339 DevPathFromTextUnit (
2340 IN CHAR16 *TextDeviceNode
2341 )
2342 {
2343 CHAR16 *LunStr;
2344 DEVICE_LOGICAL_UNIT_DEVICE_PATH *LogicalUnit;
2345
2346 LunStr = GetNextParamStr (&TextDeviceNode);
2347 LogicalUnit = (DEVICE_LOGICAL_UNIT_DEVICE_PATH *) CreateDeviceNode (
2348 MESSAGING_DEVICE_PATH,
2349 MSG_DEVICE_LOGICAL_UNIT_DP,
2350 (UINT16) sizeof (DEVICE_LOGICAL_UNIT_DEVICE_PATH)
2351 );
2352
2353 LogicalUnit->Lun = (UINT8) Strtoi (LunStr);
2354
2355 return (EFI_DEVICE_PATH_PROTOCOL *) LogicalUnit;
2356 }
2357
2358 /**
2359 Converts a text device path node to iSCSI device path structure.
2360
2361 @param TextDeviceNode The input Text device path node.
2362
2363 @return A pointer to the newly-created iSCSI device path structure.
2364
2365 **/
2366 EFI_DEVICE_PATH_PROTOCOL *
2367 DevPathFromTextiSCSI (
2368 IN CHAR16 *TextDeviceNode
2369 )
2370 {
2371 UINT16 Options;
2372 CHAR16 *NameStr;
2373 CHAR16 *PortalGroupStr;
2374 CHAR16 *LunStr;
2375 CHAR16 *HeaderDigestStr;
2376 CHAR16 *DataDigestStr;
2377 CHAR16 *AuthenticationStr;
2378 CHAR16 *ProtocolStr;
2379 CHAR8 *AsciiStr;
2380 ISCSI_DEVICE_PATH_WITH_NAME *ISCSIDevPath;
2381
2382 NameStr = GetNextParamStr (&TextDeviceNode);
2383 PortalGroupStr = GetNextParamStr (&TextDeviceNode);
2384 LunStr = GetNextParamStr (&TextDeviceNode);
2385 HeaderDigestStr = GetNextParamStr (&TextDeviceNode);
2386 DataDigestStr = GetNextParamStr (&TextDeviceNode);
2387 AuthenticationStr = GetNextParamStr (&TextDeviceNode);
2388 ProtocolStr = GetNextParamStr (&TextDeviceNode);
2389 ISCSIDevPath = (ISCSI_DEVICE_PATH_WITH_NAME *) CreateDeviceNode (
2390 MESSAGING_DEVICE_PATH,
2391 MSG_ISCSI_DP,
2392 (UINT16) (sizeof (ISCSI_DEVICE_PATH_WITH_NAME) + StrLen (NameStr))
2393 );
2394
2395 AsciiStr = ISCSIDevPath->TargetName;
2396 StrToAscii (NameStr, &AsciiStr);
2397
2398 ISCSIDevPath->TargetPortalGroupTag = (UINT16) Strtoi (PortalGroupStr);
2399 Strtoi64 (LunStr, &ISCSIDevPath->Lun);
2400
2401 Options = 0x0000;
2402 if (StrCmp (HeaderDigestStr, L"CRC32C") == 0) {
2403 Options |= 0x0002;
2404 }
2405
2406 if (StrCmp (DataDigestStr, L"CRC32C") == 0) {
2407 Options |= 0x0008;
2408 }
2409
2410 if (StrCmp (AuthenticationStr, L"None") == 0) {
2411 Options |= 0x0800;
2412 }
2413
2414 if (StrCmp (AuthenticationStr, L"CHAP_UNI") == 0) {
2415 Options |= 0x1000;
2416 }
2417
2418 ISCSIDevPath->LoginOption = (UINT16) Options;
2419
2420 ISCSIDevPath->NetworkProtocol = (UINT16) StrCmp (ProtocolStr, L"TCP");
2421
2422 return (EFI_DEVICE_PATH_PROTOCOL *) ISCSIDevPath;
2423 }
2424
2425 /**
2426 Converts a text device path node to VLAN device path structure.
2427
2428 @param TextDeviceNode The input Text device path node.
2429
2430 @return A pointer to the newly-created VLAN device path structure.
2431
2432 **/
2433 EFI_DEVICE_PATH_PROTOCOL *
2434 DevPathFromTextVlan (
2435 IN CHAR16 *TextDeviceNode
2436 )
2437 {
2438 CHAR16 *VlanStr;
2439 VLAN_DEVICE_PATH *Vlan;
2440
2441 VlanStr = GetNextParamStr (&TextDeviceNode);
2442 Vlan = (VLAN_DEVICE_PATH *) CreateDeviceNode (
2443 MESSAGING_DEVICE_PATH,
2444 MSG_VLAN_DP,
2445 (UINT16) sizeof (VLAN_DEVICE_PATH)
2446 );
2447
2448 Vlan->VlanId = (UINT16) Strtoi (VlanStr);
2449
2450 return (EFI_DEVICE_PATH_PROTOCOL *) Vlan;
2451 }
2452
2453 /**
2454 Converts a text device path node to HD device path structure.
2455
2456 @param TextDeviceNode The input Text device path node.
2457
2458 @return A pointer to the newly-created HD device path structure.
2459
2460 **/
2461 EFI_DEVICE_PATH_PROTOCOL *
2462 DevPathFromTextHD (
2463 IN CHAR16 *TextDeviceNode
2464 )
2465 {
2466 CHAR16 *PartitionStr;
2467 CHAR16 *TypeStr;
2468 CHAR16 *SignatureStr;
2469 CHAR16 *StartStr;
2470 CHAR16 *SizeStr;
2471 UINT32 Signature32;
2472 EFI_GUID SignatureGuid;
2473 HARDDRIVE_DEVICE_PATH *Hd;
2474
2475 PartitionStr = GetNextParamStr (&TextDeviceNode);
2476 TypeStr = GetNextParamStr (&TextDeviceNode);
2477 SignatureStr = GetNextParamStr (&TextDeviceNode);
2478 StartStr = GetNextParamStr (&TextDeviceNode);
2479 SizeStr = GetNextParamStr (&TextDeviceNode);
2480 Hd = (HARDDRIVE_DEVICE_PATH *) CreateDeviceNode (
2481 MEDIA_DEVICE_PATH,
2482 MEDIA_HARDDRIVE_DP,
2483 (UINT16) sizeof (HARDDRIVE_DEVICE_PATH)
2484 );
2485
2486 Hd->PartitionNumber = (UINT32) Dtoi (PartitionStr);
2487
2488 ZeroMem (Hd->Signature, 16);
2489 Hd->MBRType = (UINT8) 0;
2490
2491 if (StrCmp (TypeStr, L"MBR") == 0) {
2492 Hd->SignatureType = SIGNATURE_TYPE_MBR;
2493 Hd->MBRType = 0x01;
2494
2495 Signature32 = (UINT32) Strtoi (SignatureStr);
2496 CopyMem (Hd->Signature, &Signature32, sizeof (UINT32));
2497 } else if (StrCmp (TypeStr, L"GPT") == 0) {
2498 Hd->SignatureType = SIGNATURE_TYPE_GUID;
2499 Hd->MBRType = 0x02;
2500
2501 StrToGuid (SignatureStr, &SignatureGuid);
2502 CopyMem (Hd->Signature, &SignatureGuid, sizeof (EFI_GUID));
2503 } else {
2504 Hd->SignatureType = (UINT8) Strtoi (TypeStr);
2505 }
2506
2507 Strtoi64 (StartStr, &Hd->PartitionStart);
2508 Strtoi64 (SizeStr, &Hd->PartitionSize);
2509
2510 return (EFI_DEVICE_PATH_PROTOCOL *) Hd;
2511 }
2512
2513 /**
2514 Converts a text device path node to CDROM device path structure.
2515
2516 @param TextDeviceNode The input Text device path node.
2517
2518 @return A pointer to the newly-created CDROM device path structure.
2519
2520 **/
2521 EFI_DEVICE_PATH_PROTOCOL *
2522 DevPathFromTextCDROM (
2523 IN CHAR16 *TextDeviceNode
2524 )
2525 {
2526 CHAR16 *EntryStr;
2527 CHAR16 *StartStr;
2528 CHAR16 *SizeStr;
2529 CDROM_DEVICE_PATH *CDROMDevPath;
2530
2531 EntryStr = GetNextParamStr (&TextDeviceNode);
2532 StartStr = GetNextParamStr (&TextDeviceNode);
2533 SizeStr = GetNextParamStr (&TextDeviceNode);
2534 CDROMDevPath = (CDROM_DEVICE_PATH *) CreateDeviceNode (
2535 MEDIA_DEVICE_PATH,
2536 MEDIA_CDROM_DP,
2537 (UINT16) sizeof (CDROM_DEVICE_PATH)
2538 );
2539
2540 CDROMDevPath->BootEntry = (UINT32) Strtoi (EntryStr);
2541 Strtoi64 (StartStr, &CDROMDevPath->PartitionStart);
2542 Strtoi64 (SizeStr, &CDROMDevPath->PartitionSize);
2543
2544 return (EFI_DEVICE_PATH_PROTOCOL *) CDROMDevPath;
2545 }
2546
2547 /**
2548 Converts a text device path node to Vendor-defined media device path structure.
2549
2550 @param TextDeviceNode The input Text device path node.
2551
2552 @return A pointer to the newly-created Vendor-defined media device path structure.
2553
2554 **/
2555 EFI_DEVICE_PATH_PROTOCOL *
2556 DevPathFromTextVenMEDIA (
2557 IN CHAR16 *TextDeviceNode
2558 )
2559 {
2560 return ConvertFromTextVendor (
2561 TextDeviceNode,
2562 MEDIA_DEVICE_PATH,
2563 MEDIA_VENDOR_DP
2564 );
2565 }
2566
2567 /**
2568 Converts a text device path node to File device path structure.
2569
2570 @param TextDeviceNode The input Text device path node.
2571
2572 @return A pointer to the newly-created File device path structure.
2573
2574 **/
2575 EFI_DEVICE_PATH_PROTOCOL *
2576 DevPathFromTextFilePath (
2577 IN CHAR16 *TextDeviceNode
2578 )
2579 {
2580 FILEPATH_DEVICE_PATH *File;
2581
2582 File = (FILEPATH_DEVICE_PATH *) CreateDeviceNode (
2583 MEDIA_DEVICE_PATH,
2584 MEDIA_FILEPATH_DP,
2585 (UINT16) (sizeof (FILEPATH_DEVICE_PATH) + StrLen (TextDeviceNode) * 2)
2586 );
2587
2588 StrCpy (File->PathName, TextDeviceNode);
2589
2590 return (EFI_DEVICE_PATH_PROTOCOL *) File;
2591 }
2592
2593 /**
2594 Converts a text device path node to Media protocol device path structure.
2595
2596 @param TextDeviceNode The input Text device path node.
2597
2598 @return A pointer to the newly-created Media protocol device path structure.
2599
2600 **/
2601 EFI_DEVICE_PATH_PROTOCOL *
2602 DevPathFromTextMedia (
2603 IN CHAR16 *TextDeviceNode
2604 )
2605 {
2606 CHAR16 *GuidStr;
2607 MEDIA_PROTOCOL_DEVICE_PATH *Media;
2608
2609 GuidStr = GetNextParamStr (&TextDeviceNode);
2610 Media = (MEDIA_PROTOCOL_DEVICE_PATH *) CreateDeviceNode (
2611 MEDIA_DEVICE_PATH,
2612 MEDIA_PROTOCOL_DP,
2613 (UINT16) sizeof (MEDIA_PROTOCOL_DEVICE_PATH)
2614 );
2615
2616 StrToGuid (GuidStr, &Media->Protocol);
2617
2618 return (EFI_DEVICE_PATH_PROTOCOL *) Media;
2619 }
2620
2621 /**
2622 Converts a text device path node to firmware volume device path structure.
2623
2624 @param TextDeviceNode The input Text device path node.
2625
2626 @return A pointer to the newly-created firmware volume device path structure.
2627
2628 **/
2629 EFI_DEVICE_PATH_PROTOCOL *
2630 DevPathFromTextFv (
2631 IN CHAR16 *TextDeviceNode
2632 )
2633 {
2634 CHAR16 *GuidStr;
2635 MEDIA_FW_VOL_DEVICE_PATH *Fv;
2636
2637 GuidStr = GetNextParamStr (&TextDeviceNode);
2638 Fv = (MEDIA_FW_VOL_DEVICE_PATH *) CreateDeviceNode (
2639 MEDIA_DEVICE_PATH,
2640 MEDIA_PIWG_FW_VOL_DP,
2641 (UINT16) sizeof (MEDIA_FW_VOL_DEVICE_PATH)
2642 );
2643
2644 StrToGuid (GuidStr, &Fv->FvName);
2645
2646 return (EFI_DEVICE_PATH_PROTOCOL *) Fv;
2647 }
2648
2649 /**
2650 Converts a text device path node to firmware file device path structure.
2651
2652 @param TextDeviceNode The input Text device path node.
2653
2654 @return A pointer to the newly-created firmware file device path structure.
2655
2656 **/
2657 EFI_DEVICE_PATH_PROTOCOL *
2658 DevPathFromTextFvFile (
2659 IN CHAR16 *TextDeviceNode
2660 )
2661 {
2662 CHAR16 *GuidStr;
2663 MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *FvFile;
2664
2665 GuidStr = GetNextParamStr (&TextDeviceNode);
2666 FvFile = (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) CreateDeviceNode (
2667 MEDIA_DEVICE_PATH,
2668 MEDIA_PIWG_FW_FILE_DP,
2669 (UINT16) sizeof (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH)
2670 );
2671
2672 StrToGuid (GuidStr, &FvFile->FvFileName);
2673
2674 return (EFI_DEVICE_PATH_PROTOCOL *) FvFile;
2675 }
2676
2677 /**
2678 Converts a text device path node to text relative offset device path structure.
2679
2680 @param TextDeviceNode The input Text device path node.
2681
2682 @return A pointer to the newly-created Text device path structure.
2683
2684 **/
2685 EFI_DEVICE_PATH_PROTOCOL *
2686 DevPathFromTextRelativeOffsetRange (
2687 IN CHAR16 *TextDeviceNode
2688 )
2689 {
2690 CHAR16 *StartingOffsetStr;
2691 CHAR16 *EndingOffsetStr;
2692 MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH *Offset;
2693
2694 StartingOffsetStr = GetNextParamStr (&TextDeviceNode);
2695 EndingOffsetStr = GetNextParamStr (&TextDeviceNode);
2696 Offset = (MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH *) CreateDeviceNode (
2697 MEDIA_DEVICE_PATH,
2698 MEDIA_RELATIVE_OFFSET_RANGE_DP,
2699 (UINT16) sizeof (MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH)
2700 );
2701
2702 Strtoi64 (StartingOffsetStr, &Offset->StartingOffset);
2703 Strtoi64 (EndingOffsetStr, &Offset->EndingOffset);
2704
2705 return (EFI_DEVICE_PATH_PROTOCOL *) Offset;
2706 }
2707
2708 /**
2709 Converts a text device path node to BIOS Boot Specification device path structure.
2710
2711 @param TextDeviceNode The input Text device path node.
2712
2713 @return A pointer to the newly-created BIOS Boot Specification device path structure.
2714
2715 **/
2716 EFI_DEVICE_PATH_PROTOCOL *
2717 DevPathFromTextBBS (
2718 IN CHAR16 *TextDeviceNode
2719 )
2720 {
2721 CHAR16 *TypeStr;
2722 CHAR16 *IdStr;
2723 CHAR16 *FlagsStr;
2724 CHAR8 *AsciiStr;
2725 BBS_BBS_DEVICE_PATH *Bbs;
2726
2727 TypeStr = GetNextParamStr (&TextDeviceNode);
2728 IdStr = GetNextParamStr (&TextDeviceNode);
2729 FlagsStr = GetNextParamStr (&TextDeviceNode);
2730 Bbs = (BBS_BBS_DEVICE_PATH *) CreateDeviceNode (
2731 BBS_DEVICE_PATH,
2732 BBS_BBS_DP,
2733 (UINT16) (sizeof (BBS_BBS_DEVICE_PATH) + StrLen (IdStr))
2734 );
2735
2736 if (StrCmp (TypeStr, L"Floppy") == 0) {
2737 Bbs->DeviceType = BBS_TYPE_FLOPPY;
2738 } else if (StrCmp (TypeStr, L"HD") == 0) {
2739 Bbs->DeviceType = BBS_TYPE_HARDDRIVE;
2740 } else if (StrCmp (TypeStr, L"CDROM") == 0) {
2741 Bbs->DeviceType = BBS_TYPE_CDROM;
2742 } else if (StrCmp (TypeStr, L"PCMCIA") == 0) {
2743 Bbs->DeviceType = BBS_TYPE_PCMCIA;
2744 } else if (StrCmp (TypeStr, L"USB") == 0) {
2745 Bbs->DeviceType = BBS_TYPE_USB;
2746 } else if (StrCmp (TypeStr, L"Network") == 0) {
2747 Bbs->DeviceType = BBS_TYPE_EMBEDDED_NETWORK;
2748 } else {
2749 Bbs->DeviceType = (UINT16) Strtoi (TypeStr);
2750 }
2751
2752 AsciiStr = Bbs->String;
2753 StrToAscii (IdStr, &AsciiStr);
2754
2755 Bbs->StatusFlag = (UINT16) Strtoi (FlagsStr);
2756
2757 return (EFI_DEVICE_PATH_PROTOCOL *) Bbs;
2758 }
2759
2760 /**
2761 Converts a text device path node to SATA device path structure.
2762
2763 @param TextDeviceNode The input Text device path node.
2764
2765 @return A pointer to the newly-created SATA device path structure.
2766
2767 **/
2768 EFI_DEVICE_PATH_PROTOCOL *
2769 DevPathFromTextSata (
2770 IN CHAR16 *TextDeviceNode
2771 )
2772 {
2773 SATA_DEVICE_PATH *Sata;
2774 CHAR16 *Param1;
2775 CHAR16 *Param2;
2776 CHAR16 *Param3;
2777
2778 //
2779 // The PMPN is optional.
2780 //
2781 Param1 = GetNextParamStr (&TextDeviceNode);
2782 Param2 = GetNextParamStr (&TextDeviceNode);
2783 Param3 = NULL;
2784 if (!IS_NULL (TextDeviceNode)) {
2785 Param3 = GetNextParamStr (&TextDeviceNode);
2786 }
2787
2788 Sata = (SATA_DEVICE_PATH *) CreateDeviceNode (
2789 MESSAGING_DEVICE_PATH,
2790 MSG_SATA_DP,
2791 (UINT16) sizeof (SATA_DEVICE_PATH)
2792 );
2793 Sata->HBAPortNumber = (UINT16) Xtoi (Param1);
2794 if (Param3 != NULL) {
2795 Sata->PortMultiplierPortNumber = (UINT16) Xtoi (Param2);
2796 Param2 = Param3;
2797 } else {
2798 Sata->PortMultiplierPortNumber = SATA_HBA_DIRECT_CONNECT_FLAG;
2799 }
2800 Sata->Lun = (UINT16) Xtoi (Param2);
2801
2802 return (EFI_DEVICE_PATH_PROTOCOL *) Sata;
2803 }
2804
2805 GLOBAL_REMOVE_IF_UNREFERENCED DEVICE_PATH_FROM_TEXT_TABLE DevPathFromTextTable[] = {
2806 {L"Pci", DevPathFromTextPci},
2807 {L"PcCard", DevPathFromTextPcCard},
2808 {L"MemoryMapped", DevPathFromTextMemoryMapped},
2809 {L"VenHw", DevPathFromTextVenHw},
2810 {L"Ctrl", DevPathFromTextCtrl},
2811 {L"Acpi", DevPathFromTextAcpi},
2812 {L"PciRoot", DevPathFromTextPciRoot},
2813 {L"Floppy", DevPathFromTextFloppy},
2814 {L"Keyboard", DevPathFromTextKeyboard},
2815 {L"Serial", DevPathFromTextSerial},
2816 {L"ParallelPort", DevPathFromTextParallelPort},
2817 {L"AcpiEx", DevPathFromTextAcpiEx},
2818 {L"AcpiExp", DevPathFromTextAcpiExp},
2819 {L"AcpiAdr", DevPathFromTextAcpiAdr},
2820 {L"Ata", DevPathFromTextAta},
2821 {L"Scsi", DevPathFromTextScsi},
2822 {L"Fibre", DevPathFromTextFibre},
2823 {L"I1394", DevPathFromText1394},
2824 {L"USB", DevPathFromTextUsb},
2825 {L"I2O", DevPathFromTextI2O},
2826 {L"Infiniband", DevPathFromTextInfiniband},
2827 {L"VenMsg", DevPathFromTextVenMsg},
2828 {L"VenPcAnsi", DevPathFromTextVenPcAnsi},
2829 {L"VenVt100", DevPathFromTextVenVt100},
2830 {L"VenVt100Plus", DevPathFromTextVenVt100Plus},
2831 {L"VenUtf8", DevPathFromTextVenUtf8},
2832 {L"UartFlowCtrl", DevPathFromTextUartFlowCtrl},
2833 {L"SAS", DevPathFromTextSAS},
2834 {L"DebugPort", DevPathFromTextDebugPort},
2835 {L"MAC", DevPathFromTextMAC},
2836 {L"IPv4", DevPathFromTextIPv4},
2837 {L"IPv6", DevPathFromTextIPv6},
2838 {L"Uart", DevPathFromTextUart},
2839 {L"UsbClass", DevPathFromTextUsbClass},
2840 {L"UsbAudio", DevPathFromTextUsbAudio},
2841 {L"UsbCDCControl", DevPathFromTextUsbCDCControl},
2842 {L"UsbHID", DevPathFromTextUsbHID},
2843 {L"UsbImage", DevPathFromTextUsbImage},
2844 {L"UsbPrinter", DevPathFromTextUsbPrinter},
2845 {L"UsbMassStorage", DevPathFromTextUsbMassStorage},
2846 {L"UsbHub", DevPathFromTextUsbHub},
2847 {L"UsbCDCData", DevPathFromTextUsbCDCData},
2848 {L"UsbSmartCard", DevPathFromTextUsbSmartCard},
2849 {L"UsbVideo", DevPathFromTextUsbVideo},
2850 {L"UsbDiagnostic", DevPathFromTextUsbDiagnostic},
2851 {L"UsbWireless", DevPathFromTextUsbWireless},
2852 {L"UsbDeviceFirmwareUpdate", DevPathFromTextUsbDeviceFirmwareUpdate},
2853 {L"UsbIrdaBridge", DevPathFromTextUsbIrdaBridge},
2854 {L"UsbTestAndMeasurement", DevPathFromTextUsbTestAndMeasurement},
2855 {L"UsbWwid", DevPathFromTextUsbWwid},
2856 {L"Unit", DevPathFromTextUnit},
2857 {L"iSCSI", DevPathFromTextiSCSI},
2858 {L"Vlan", DevPathFromTextVlan},
2859 {L"HD", DevPathFromTextHD},
2860 {L"CDROM", DevPathFromTextCDROM},
2861 {L"VenMEDIA", DevPathFromTextVenMEDIA},
2862 {L"Media", DevPathFromTextMedia},
2863 {L"Fv", DevPathFromTextFv},
2864 {L"FvFile", DevPathFromTextFvFile},
2865 {L"Offset", DevPathFromTextRelativeOffsetRange},
2866 {L"BBS", DevPathFromTextBBS},
2867 {L"Sata", DevPathFromTextSata},
2868 {NULL, NULL}
2869 };
2870
2871 /**
2872 Convert text to the binary representation of a device node.
2873
2874 @param TextDeviceNode TextDeviceNode points to the text representation of a device
2875 node. Conversion starts with the first character and continues
2876 until the first non-device node character.
2877
2878 @return A pointer to the EFI device node or NULL if TextDeviceNode is NULL or there was
2879 insufficient memory or text unsupported.
2880
2881 **/
2882 EFI_DEVICE_PATH_PROTOCOL *
2883 EFIAPI
2884 ConvertTextToDeviceNode (
2885 IN CONST CHAR16 *TextDeviceNode
2886 )
2887 {
2888 DUMP_NODE DumpNode;
2889 CHAR16 *ParamStr;
2890 EFI_DEVICE_PATH_PROTOCOL *DeviceNode;
2891 CHAR16 *DeviceNodeStr;
2892 UINTN Index;
2893
2894 if ((TextDeviceNode == NULL) || (IS_NULL (*TextDeviceNode))) {
2895 return NULL;
2896 }
2897
2898 ParamStr = NULL;
2899 DumpNode = NULL;
2900 DeviceNodeStr = StrDuplicate (TextDeviceNode);
2901 ASSERT (DeviceNodeStr != NULL);
2902
2903 for (Index = 0; DevPathFromTextTable[Index].Function != NULL; Index++) {
2904 ParamStr = GetParamByNodeName (DeviceNodeStr, DevPathFromTextTable[Index].DevicePathNodeText);
2905 if (ParamStr != NULL) {
2906 DumpNode = DevPathFromTextTable[Index].Function;
2907 break;
2908 }
2909 }
2910
2911 if (DumpNode == NULL) {
2912 //
2913 // A file path
2914 //
2915 DumpNode = DevPathFromTextFilePath;
2916 DeviceNode = DumpNode (DeviceNodeStr);
2917 } else {
2918 DeviceNode = DumpNode (ParamStr);
2919 FreePool (ParamStr);
2920 }
2921
2922 FreePool (DeviceNodeStr);
2923
2924 return DeviceNode;
2925 }
2926
2927 /**
2928 Convert text to the binary representation of a device path.
2929
2930
2931 @param TextDevicePath TextDevicePath points to the text representation of a device
2932 path. Conversion starts with the first character and continues
2933 until the first non-device node character.
2934
2935 @return A pointer to the allocated device path or NULL if TextDeviceNode is NULL or
2936 there was insufficient memory.
2937
2938 **/
2939 EFI_DEVICE_PATH_PROTOCOL *
2940 EFIAPI
2941 ConvertTextToDevicePath (
2942 IN CONST CHAR16 *TextDevicePath
2943 )
2944 {
2945 DUMP_NODE DumpNode;
2946 CHAR16 *ParamStr;
2947 EFI_DEVICE_PATH_PROTOCOL *DeviceNode;
2948 UINTN Index;
2949 EFI_DEVICE_PATH_PROTOCOL *NewDevicePath;
2950 CHAR16 *DevicePathStr;
2951 CHAR16 *Str;
2952 CHAR16 *DeviceNodeStr;
2953 UINT8 IsInstanceEnd;
2954 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
2955
2956 if ((TextDevicePath == NULL) || (IS_NULL (*TextDevicePath))) {
2957 return NULL;
2958 }
2959
2960 DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) AllocatePool (END_DEVICE_PATH_LENGTH);
2961 ASSERT (DevicePath != NULL);
2962 SetDevicePathEndNode (DevicePath);
2963
2964 ParamStr = NULL;
2965 DeviceNodeStr = NULL;
2966 DevicePathStr = StrDuplicate (TextDevicePath);
2967
2968 Str = DevicePathStr;
2969 while ((DeviceNodeStr = GetNextDeviceNodeStr (&Str, &IsInstanceEnd)) != NULL) {
2970 DumpNode = NULL;
2971 for (Index = 0; DevPathFromTextTable[Index].Function != NULL; Index++) {
2972 ParamStr = GetParamByNodeName (DeviceNodeStr, DevPathFromTextTable[Index].DevicePathNodeText);
2973 if (ParamStr != NULL) {
2974 DumpNode = DevPathFromTextTable[Index].Function;
2975 break;
2976 }
2977 }
2978
2979 if (DumpNode == NULL) {
2980 //
2981 // A file path
2982 //
2983 DumpNode = DevPathFromTextFilePath;
2984 DeviceNode = DumpNode (DeviceNodeStr);
2985 } else {
2986 DeviceNode = DumpNode (ParamStr);
2987 FreePool (ParamStr);
2988 }
2989
2990 NewDevicePath = AppendDeviceNodeProtocolInterface (DevicePath, DeviceNode);
2991 FreePool (DevicePath);
2992 FreePool (DeviceNode);
2993 DevicePath = NewDevicePath;
2994
2995 if (IsInstanceEnd != 0) {
2996 DeviceNode = (EFI_DEVICE_PATH_PROTOCOL *) AllocatePool (END_DEVICE_PATH_LENGTH);
2997 ASSERT (DeviceNode != NULL);
2998 SET_DEVICE_PATH_INSTANCE_END_NODE (DeviceNode);
2999
3000 NewDevicePath = AppendDeviceNodeProtocolInterface (DevicePath, DeviceNode);
3001 FreePool (DevicePath);
3002 FreePool (DeviceNode);
3003 DevicePath = NewDevicePath;
3004 }
3005 }
3006
3007 FreePool (DevicePathStr);
3008 return DevicePath;
3009 }
EFI Development Kit II mirror for PVE