]> 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
Check in following modules,
[mirror_edk2.git] / MdeModulePkg / Universal / DevicePathDxe / DevicePathFromText.c
1 /*++
2
3 Copyright (c) 2006, Intel Corporation
4 All rights reserved. This program and the accompanying materials
5 are licensed and made available under the terms and conditions of the BSD License
6 which accompanies this distribution. The full text of the license may be found at
7 http://opensource.org/licenses/bsd-license.php
8
9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
11
12 Module Name:
13
14 DevicePathFromText.c
15
16 Abstract:
17
18 DevicePathFromText protocol as defined in the UEFI 2.0 specification.
19
20 --*/
21
22 //
23 // Include common header file for this module.
24 //
25 #include "CommonHeader.h"
26
27 #include "DevicePath.h"
28
29 STATIC
30 CHAR16 *
31 StrDuplicate (
32 IN CONST CHAR16 *Src
33 )
34 /*++
35
36 Routine Description:
37 Duplicate a string
38
39 Arguments:
40 Src - Source string
41
42 Returns:
43 Duplicated string
44
45 --*/
46 {
47 UINTN Length;
48 CHAR16 *ReturnStr;
49
50 Length = StrLen ((CHAR16 *) Src);
51
52 ReturnStr = AllocateCopyPool ((Length + 1) * sizeof (CHAR16), (VOID *) Src);
53
54 return ReturnStr;
55 }
56
57 STATIC
58 CHAR16 *
59 GetParamByNodeName (
60 IN CHAR16 *Str,
61 IN CHAR16 *NodeName
62 )
63 /*++
64
65 Routine Description:
66 Get parameter in a pair of parentheses follow the given node name.
67 For example, given the "Pci(0,1)" and NodeName "Pci", it returns "0,1".
68
69 Arguments:
70 Str - Device Path Text
71 NodeName - Name of the node
72
73 Returns:
74 Parameter text for the node
75
76 --*/
77 {
78 CHAR16 *ParamStr;
79 CHAR16 *StrPointer;
80 UINTN NodeNameLength;
81 UINTN ParameterLength;
82
83 //
84 // Check whether the node name matchs
85 //
86 NodeNameLength = StrLen (NodeName);
87 if (CompareMem (Str, NodeName, NodeNameLength * sizeof (CHAR16)) != 0) {
88 return NULL;
89 }
90
91 ParamStr = Str + NodeNameLength;
92 if (!IS_LEFT_PARENTH (*ParamStr)) {
93 return NULL;
94 }
95
96 //
97 // Skip the found '(' and find first occurrence of ')'
98 //
99 ParamStr++;
100 ParameterLength = 0;
101 StrPointer = ParamStr;
102 while (!IS_NULL (*StrPointer)) {
103 if (IS_RIGHT_PARENTH (*StrPointer)) {
104 break;
105 }
106 StrPointer++;
107 ParameterLength++;
108 }
109 if (IS_NULL (*StrPointer)) {
110 //
111 // ')' not found
112 //
113 return NULL;
114 }
115
116 ParamStr = AllocateCopyPool ((ParameterLength + 1) * sizeof (CHAR16), ParamStr);
117 if (ParamStr == NULL) {
118 return NULL;
119 }
120 //
121 // Terminate the parameter string
122 //
123 ParamStr[ParameterLength] = L'\0';
124
125 return ParamStr;
126 }
127
128 STATIC
129 CHAR16 *
130 SplitStr (
131 IN OUT CHAR16 **List,
132 IN CHAR16 Separator
133 )
134 /*++
135
136 Routine Description:
137 Get current sub-string from a string list, before return
138 the list header is moved to next sub-string. The sub-string is separated
139 by the specified character. For example, the separator is ',', the string
140 list is "2,0,3", it returns "2", the remain list move to "2,3"
141
142 Arguments:
143 List - A string list separated by the specified separator
144 Separator - The separator character
145
146 Returns:
147 pointer - The current sub-string
148
149 --*/
150 {
151 CHAR16 *Str;
152 CHAR16 *ReturnStr;
153
154 Str = *List;
155 ReturnStr = Str;
156
157 if (IS_NULL (*Str)) {
158 return ReturnStr;
159 }
160
161 //
162 // Find first occurrence of the separator
163 //
164 while (!IS_NULL (*Str)) {
165 if (*Str == Separator) {
166 break;
167 }
168 Str++;
169 }
170
171 if (*Str == Separator) {
172 //
173 // Find a sub-string, terminate it
174 //
175 *Str = L'\0';
176 Str++;
177 }
178
179 //
180 // Move to next sub-string
181 //
182 *List = Str;
183
184 return ReturnStr;
185 }
186
187 STATIC
188 CHAR16 *
189 GetNextParamStr (
190 IN OUT CHAR16 **List
191 )
192 {
193 //
194 // The separator is comma
195 //
196 return SplitStr (List, L',');
197 }
198
199 STATIC
200 CHAR16 *
201 GetNextDeviceNodeStr (
202 IN OUT CHAR16 **DevicePath,
203 OUT BOOLEAN *IsInstanceEnd
204 )
205 /*++
206
207 Routine Description:
208 Get one device node from entire device path text.
209
210 Arguments:
211 Str - The entire device path text string
212 IsInstanceEnd - This node is the end of a device path instance
213
214 Returns:
215 a pointer - A device node text
216 NULL - No more device node available
217
218 --*/
219 {
220 CHAR16 *Str;
221 CHAR16 *ReturnStr;
222 UINTN ParenthesesStack;
223
224 Str = *DevicePath;
225 if (IS_NULL (*Str)) {
226 return NULL;
227 }
228
229 //
230 // Skip the leading '/', '(', ')' and ','
231 //
232 while (!IS_NULL (*Str)) {
233 if (!IS_SLASH (*Str) &&
234 !IS_COMMA (*Str) &&
235 !IS_LEFT_PARENTH (*Str) &&
236 !IS_RIGHT_PARENTH (*Str)) {
237 break;
238 }
239 Str++;
240 }
241
242 ReturnStr = Str;
243
244 //
245 // Scan for the separator of this device node, '/' or ','
246 //
247 ParenthesesStack = 0;
248 while (!IS_NULL (*Str)) {
249 if ((IS_COMMA (*Str) || IS_SLASH (*Str)) && (ParenthesesStack == 0)) {
250 break;
251 }
252
253 if (IS_LEFT_PARENTH (*Str)) {
254 ParenthesesStack++;
255 } else if (IS_RIGHT_PARENTH (*Str)) {
256 ParenthesesStack--;
257 }
258
259 Str++;
260 }
261
262 if (ParenthesesStack != 0) {
263 //
264 // The '(' doesn't pair with ')', invalid device path text
265 //
266 return NULL;
267 }
268
269 if (IS_COMMA (*Str)) {
270 *IsInstanceEnd = TRUE;
271 *Str = L'\0';
272 Str++;
273 } else {
274 *IsInstanceEnd = FALSE;
275 if (!IS_NULL (*Str)) {
276 *Str = L'\0';
277 Str++;
278 }
279 }
280
281 *DevicePath = Str;
282
283 return ReturnStr;
284 }
285
286 STATIC
287 BOOLEAN
288 IsHexDigit (
289 OUT UINT8 *Digit,
290 IN CHAR16 Char
291 )
292 /*++
293
294 Routine Description:
295 Determines if a Unicode character is a hexadecimal digit.
296 The test is case insensitive.
297
298 Arguments:
299 Digit - Pointer to byte that receives the value of the hex character.
300 Char - Unicode character to test.
301
302 Returns:
303 TRUE - If the character is a hexadecimal digit.
304 FALSE - Otherwise.
305
306 --*/
307 {
308 if ((Char >= L'0') && (Char <= L'9')) {
309 *Digit = (UINT8) (Char - L'0');
310 return TRUE;
311 }
312
313 if ((Char >= L'A') && (Char <= L'F')) {
314 *Digit = (UINT8) (Char - L'A' + 0x0A);
315 return TRUE;
316 }
317
318 if ((Char >= L'a') && (Char <= L'f')) {
319 *Digit = (UINT8) (Char - L'a' + 0x0A);
320 return TRUE;
321 }
322
323 return FALSE;
324 }
325
326 STATIC
327 EFI_STATUS
328 HexStringToBuf (
329 IN OUT UINT8 *Buf,
330 IN OUT UINTN *Len,
331 IN CHAR16 *Str,
332 OUT UINTN *ConvertedStrLen OPTIONAL
333 )
334 /*++
335
336 Routine Description:
337 Converts Unicode string to binary buffer.
338 The conversion may be partial.
339 The first character in the string that is not hex digit stops the conversion.
340 At a minimum, any blob of data could be represented as a hex string.
341
342 Arguments:
343 Buf - Pointer to buffer that receives the data.
344 Len - Length in bytes of the buffer to hold converted data.
345 If routine return with EFI_SUCCESS, containing length of converted data.
346 If routine return with EFI_BUFFER_TOO_SMALL, containg length of buffer desired.
347 Str - String to be converted from.
348 ConvertedStrLen - Length of the Hex String consumed.
349
350 Returns:
351 EFI_SUCCESS: Routine Success.
352 EFI_BUFFER_TOO_SMALL: The buffer is too small to hold converted data.
353 EFI_
354
355 --*/
356 {
357 UINTN HexCnt;
358 UINTN Idx;
359 UINTN BufferLength;
360 UINT8 Digit;
361 UINT8 Byte;
362
363 //
364 // Find out how many hex characters the string has.
365 //
366 for (Idx = 0, HexCnt = 0; IsHexDigit (&Digit, Str[Idx]); Idx++, HexCnt++);
367
368 if (HexCnt == 0) {
369 *Len = 0;
370 return EFI_SUCCESS;
371 }
372 //
373 // Two Unicode characters make up 1 buffer byte. Round up.
374 //
375 BufferLength = (HexCnt + 1) / 2;
376
377 //
378 // Test if buffer is passed enough.
379 //
380 if (BufferLength > (*Len)) {
381 *Len = BufferLength;
382 return EFI_BUFFER_TOO_SMALL;
383 }
384
385 *Len = BufferLength;
386
387 for (Idx = 0; Idx < HexCnt; Idx++) {
388
389 IsHexDigit (&Digit, Str[HexCnt - 1 - Idx]);
390
391 //
392 // For odd charaters, write the lower nibble for each buffer byte,
393 // and for even characters, the upper nibble.
394 //
395 if ((Idx & 1) == 0) {
396 Byte = Digit;
397 } else {
398 Byte = Buf[Idx / 2];
399 Byte &= 0x0F;
400 Byte = (UINT8) (Byte | Digit << 4);
401 }
402
403 Buf[Idx / 2] = Byte;
404 }
405
406 if (ConvertedStrLen != NULL) {
407 *ConvertedStrLen = HexCnt;
408 }
409
410 return EFI_SUCCESS;
411 }
412
413 STATIC
414 CHAR16 *
415 TrimHexStr (
416 IN CHAR16 *Str
417 )
418 /*++
419
420 Routine Description:
421 Skip the leading white space and '0x' or '0X' of a hex string
422
423 Arguments:
424 Str - The hex string
425
426 Returns:
427
428 --*/
429 {
430 //
431 // skip preceeding white space
432 //
433 while (*Str && *Str == ' ') {
434 Str += 1;
435 }
436 //
437 // skip preceeding zeros
438 //
439 while (*Str && *Str == '0') {
440 Str += 1;
441 }
442 //
443 // skip preceeding character 'x' or 'X'
444 //
445 if (*Str && (*Str == 'x' || *Str == 'X')) {
446 Str += 1;
447 }
448
449 return Str;
450 }
451
452 STATIC
453 UINTN
454 Xtoi (
455 IN CHAR16 *Str
456 )
457 /*++
458
459 Routine Description:
460
461 Convert hex string to uint
462
463 Arguments:
464
465 Str - The string
466
467 Returns:
468
469 --*/
470 {
471 UINTN Rvalue;
472 UINTN Length;
473
474 ASSERT (Str != NULL);
475
476 //
477 // convert hex digits
478 //
479 Rvalue = 0;
480 Length = sizeof (UINTN);
481 HexStringToBuf ((UINT8 *) &Rvalue, &Length, TrimHexStr (Str), NULL);
482
483 return Rvalue;
484 }
485
486 STATIC
487 VOID
488 Xtoi64 (
489 IN CHAR16 *Str,
490 IN UINT64 *Data
491 )
492 /*++
493
494 Routine Description:
495
496 Convert hex string to 64 bit data.
497
498 Arguments:
499
500 Str - The string
501
502 Returns:
503
504 --*/
505 {
506 UINTN Length;
507
508 *Data = 0;
509 Length = sizeof (UINT64);
510 HexStringToBuf ((UINT8 *) Data, &Length, TrimHexStr (Str), NULL);
511 }
512
513 STATIC
514 UINTN
515 Atoi (
516 IN CHAR16 *str
517 )
518 /*++
519
520 Routine Description:
521
522 Convert decimal string to uint
523
524 Arguments:
525
526 Str - The string
527
528 Returns:
529
530 --*/
531 {
532 UINTN Rvalue;
533 CHAR16 Char;
534 UINTN High;
535 UINTN Low;
536
537 ASSERT (str != NULL);
538
539 High = (UINTN) -1 / 10;
540 Low = (UINTN) -1 % 10;
541 //
542 // skip preceeding white space
543 //
544 while (*str && *str == ' ') {
545 str += 1;
546 }
547 //
548 // convert digits
549 //
550 Rvalue = 0;
551 Char = *(str++);
552 while (Char) {
553 if (Char >= '0' && Char <= '9') {
554 if ((Rvalue > High || Rvalue == High) && (Char - '0' > (INTN) Low)) {
555 return (UINTN) -1;
556 }
557
558 Rvalue = (Rvalue * 10) + Char - '0';
559 } else {
560 break;
561 }
562
563 Char = *(str++);
564 }
565
566 return Rvalue;
567 }
568
569 STATIC
570 EFI_STATUS
571 StrToBuf (
572 OUT UINT8 *Buf,
573 IN UINTN BufferLength,
574 IN CHAR16 *Str
575 )
576 {
577 UINTN Index;
578 UINTN StrLength;
579 UINT8 Digit;
580 UINT8 Byte;
581
582 //
583 // Two hex char make up one byte
584 //
585 StrLength = BufferLength * sizeof (CHAR16);
586
587 for(Index = 0; Index < StrLength; Index++, Str++) {
588
589 IsHexDigit (&Digit, *Str);
590
591 //
592 // For odd charaters, write the upper nibble for each buffer byte,
593 // and for even characters, the lower nibble.
594 //
595 if ((Index & 1) == 0) {
596 Byte = (UINT8) (Digit << 4);
597 } else {
598 Byte = Buf[Index / 2];
599 Byte &= 0xF0;
600 Byte = (UINT8) (Byte | Digit);
601 }
602
603 Buf[Index / 2] = Byte;
604 }
605
606 return EFI_SUCCESS;
607 }
608
609 STATIC
610 EFI_STATUS
611 StrToGuid (
612 IN CHAR16 *Str,
613 OUT EFI_GUID *Guid
614 )
615 {
616 UINTN BufferLength;
617 UINTN ConvertedStrLen;
618 EFI_STATUS Status;
619
620 BufferLength = sizeof (Guid->Data1);
621 Status = HexStringToBuf ((UINT8 *) &Guid->Data1, &BufferLength, Str, &ConvertedStrLen);
622 if (EFI_ERROR (Status)) {
623 return Status;
624 }
625 Str += ConvertedStrLen;
626 if (IS_HYPHEN (*Str)) {
627 Str++;
628 } else {
629 return EFI_UNSUPPORTED;
630 }
631
632 BufferLength = sizeof (Guid->Data2);
633 Status = HexStringToBuf ((UINT8 *) &Guid->Data2, &BufferLength, Str, &ConvertedStrLen);
634 if (EFI_ERROR (Status)) {
635 return Status;
636 }
637 Str += ConvertedStrLen;
638 if (IS_HYPHEN (*Str)) {
639 Str++;
640 } else {
641 return EFI_UNSUPPORTED;
642 }
643
644 BufferLength = sizeof (Guid->Data3);
645 Status = HexStringToBuf ((UINT8 *) &Guid->Data3, &BufferLength, Str, &ConvertedStrLen);
646 if (EFI_ERROR (Status)) {
647 return Status;
648 }
649 Str += ConvertedStrLen;
650 if (IS_HYPHEN (*Str)) {
651 Str++;
652 } else {
653 return EFI_UNSUPPORTED;
654 }
655
656 StrToBuf (&Guid->Data4[0], 2, Str);
657 //
658 // Skip 2 byte hex chars
659 //
660 Str += 2 * 2;
661
662 if (IS_HYPHEN (*Str)) {
663 Str++;
664 } else {
665 return EFI_UNSUPPORTED;
666 }
667 StrToBuf (&Guid->Data4[2], 6, Str);
668
669 return EFI_SUCCESS;
670 }
671
672 STATIC
673 VOID
674 StrToIPv4Addr (
675 IN OUT CHAR16 **Str,
676 OUT EFI_IPv4_ADDRESS *IPv4Addr
677 )
678 {
679 UINTN Index;
680
681 for (Index = 0; Index < 4; Index++) {
682 IPv4Addr->Addr[Index] = (UINT8) Atoi (SplitStr (Str, L'.'));
683 }
684 }
685
686 STATIC
687 VOID
688 StrToIPv6Addr (
689 IN OUT CHAR16 **Str,
690 OUT EFI_IPv6_ADDRESS *IPv6Addr
691 )
692 {
693 UINTN Index;
694 UINT16 Data;
695
696 for (Index = 0; Index < 8; Index++) {
697 Data = (UINT16) Xtoi (SplitStr (Str, L':'));
698 IPv6Addr->Addr[Index * 2] = (UINT8) (Data >> 8);
699 IPv6Addr->Addr[Index * 2 + 1] = (UINT8) (Data & 0xff);
700 }
701 }
702
703 STATIC
704 VOID
705 StrToAscii (
706 IN CHAR16 *Str,
707 IN OUT CHAR8 **AsciiStr
708 )
709 {
710 CHAR8 *Dest;
711
712 Dest = *AsciiStr;
713 while (!IS_NULL (*Str)) {
714 *(Dest++) = (CHAR8) *(Str++);
715 }
716 *Dest = 0;
717
718 //
719 // Return the string next to it
720 //
721 *AsciiStr = Dest + 1;
722 }
723
724 STATIC
725 EFI_DEVICE_PATH_PROTOCOL *
726 DevPathFromTextPci (
727 IN CHAR16 *TextDeviceNode
728 )
729 {
730 CHAR16 *FunctionStr;
731 CHAR16 *DeviceStr;
732 PCI_DEVICE_PATH *Pci;
733
734 FunctionStr = GetNextParamStr (&TextDeviceNode);
735 DeviceStr = GetNextParamStr (&TextDeviceNode);
736 Pci = (PCI_DEVICE_PATH *) CreateDeviceNode (
737 HARDWARE_DEVICE_PATH,
738 HW_PCI_DP,
739 sizeof (PCI_DEVICE_PATH)
740 );
741
742 Pci->Function = (UINT8) Xtoi (FunctionStr);
743 Pci->Device = (UINT8) Xtoi (DeviceStr);
744
745 return (EFI_DEVICE_PATH_PROTOCOL *) Pci;
746 }
747
748 STATIC
749 EFI_DEVICE_PATH_PROTOCOL *
750 DevPathFromTextPcCard (
751 IN CHAR16 *TextDeviceNode
752 )
753 {
754 CHAR16 *FunctionNumberStr;
755 PCCARD_DEVICE_PATH *Pccard;
756
757 FunctionNumberStr = GetNextParamStr (&TextDeviceNode);
758 Pccard = (PCCARD_DEVICE_PATH *) CreateDeviceNode (
759 HARDWARE_DEVICE_PATH,
760 HW_PCCARD_DP,
761 sizeof (PCCARD_DEVICE_PATH)
762 );
763
764 Pccard->FunctionNumber = (UINT8) Xtoi (FunctionNumberStr);
765
766 return (EFI_DEVICE_PATH_PROTOCOL *) Pccard;
767 }
768
769 STATIC
770 EFI_DEVICE_PATH_PROTOCOL *
771 DevPathFromTextMemoryMapped (
772 IN CHAR16 *TextDeviceNode
773 )
774 {
775 CHAR16 *StartingAddressStr;
776 CHAR16 *EndingAddressStr;
777 MEMMAP_DEVICE_PATH *MemMap;
778
779 StartingAddressStr = GetNextParamStr (&TextDeviceNode);
780 EndingAddressStr = GetNextParamStr (&TextDeviceNode);
781 MemMap = (MEMMAP_DEVICE_PATH *) CreateDeviceNode (
782 HARDWARE_DEVICE_PATH,
783 HW_MEMMAP_DP,
784 sizeof (MEMMAP_DEVICE_PATH)
785 );
786
787 MemMap->MemoryType = 0;
788
789 Xtoi64 (StartingAddressStr, &MemMap->StartingAddress);
790 Xtoi64 (EndingAddressStr, &MemMap->EndingAddress);
791
792 return (EFI_DEVICE_PATH_PROTOCOL *) MemMap;
793 }
794
795 STATIC
796 EFI_DEVICE_PATH_PROTOCOL *
797 ConvertFromTextVendor (
798 IN CHAR16 *TextDeviceNode,
799 IN UINT8 Type,
800 IN UINT8 SubType
801 )
802 {
803 CHAR16 *GuidStr;
804 CHAR16 *DataStr;
805 UINTN Length;
806 VENDOR_DEVICE_PATH *Vendor;
807
808 GuidStr = GetNextParamStr (&TextDeviceNode);
809
810 DataStr = GetNextParamStr (&TextDeviceNode);
811 Length = StrLen (DataStr);
812 //
813 // Two hex characters make up 1 buffer byte
814 //
815 Length = (Length + 1) / 2;
816
817 Vendor = (VENDOR_DEVICE_PATH *) CreateDeviceNode (
818 Type,
819 SubType,
820 sizeof (VENDOR_DEVICE_PATH) + (UINT16) Length
821 );
822
823 StrToGuid (GuidStr, &Vendor->Guid);
824 StrToBuf (((UINT8 *) Vendor) + sizeof (VENDOR_DEVICE_PATH), Length, DataStr);
825
826 return (EFI_DEVICE_PATH_PROTOCOL *) Vendor;
827 }
828
829 STATIC
830 EFI_DEVICE_PATH_PROTOCOL *
831 DevPathFromTextVenHw (
832 IN CHAR16 *TextDeviceNode
833 )
834 {
835 return ConvertFromTextVendor (
836 TextDeviceNode,
837 HARDWARE_DEVICE_PATH,
838 HW_VENDOR_DP
839 );
840 }
841
842 STATIC
843 EFI_DEVICE_PATH_PROTOCOL *
844 DevPathFromTextCtrl (
845 IN CHAR16 *TextDeviceNode
846 )
847 {
848 CHAR16 *ControllerStr;
849 CONTROLLER_DEVICE_PATH *Controller;
850
851 ControllerStr = GetNextParamStr (&TextDeviceNode);
852 Controller = (CONTROLLER_DEVICE_PATH *) CreateDeviceNode (
853 HARDWARE_DEVICE_PATH,
854 HW_CONTROLLER_DP,
855 sizeof (CONTROLLER_DEVICE_PATH)
856 );
857 Controller->ControllerNumber = (UINT32) Xtoi (ControllerStr);
858
859 return (EFI_DEVICE_PATH_PROTOCOL *) Controller;
860 }
861
862 STATIC
863 EFI_DEVICE_PATH_PROTOCOL *
864 DevPathFromTextAcpi (
865 IN CHAR16 *TextDeviceNode
866 )
867 {
868 CHAR16 *HIDStr;
869 CHAR16 *UIDStr;
870 ACPI_HID_DEVICE_PATH *Acpi;
871
872 HIDStr = GetNextParamStr (&TextDeviceNode);
873 UIDStr = GetNextParamStr (&TextDeviceNode);
874 Acpi = (ACPI_HID_DEVICE_PATH *) CreateDeviceNode (
875 ACPI_DEVICE_PATH,
876 ACPI_DP,
877 sizeof (ACPI_HID_DEVICE_PATH)
878 );
879
880 if ((HIDStr[0] == L'P') && (HIDStr[1] == L'N') && (HIDStr[2] == L'P')) {
881 HIDStr += 3;
882 }
883
884 Acpi->HID = EISA_PNP_ID (Xtoi (HIDStr));
885 Acpi->UID = (UINT32) Xtoi (UIDStr);
886
887 return (EFI_DEVICE_PATH_PROTOCOL *) Acpi;
888 }
889
890 STATIC
891 EFI_DEVICE_PATH_PROTOCOL *
892 ConvertFromTextAcpi (
893 IN CHAR16 *TextDeviceNode,
894 IN UINT32 Hid
895 )
896 {
897 CHAR16 *UIDStr;
898 ACPI_HID_DEVICE_PATH *Acpi;
899
900 UIDStr = GetNextParamStr (&TextDeviceNode);
901 Acpi = (ACPI_HID_DEVICE_PATH *) CreateDeviceNode (
902 ACPI_DEVICE_PATH,
903 ACPI_DP,
904 sizeof (ACPI_HID_DEVICE_PATH)
905 );
906
907 Acpi->HID = Hid;
908 Acpi->UID = (UINT32) Xtoi (UIDStr);
909
910 return (EFI_DEVICE_PATH_PROTOCOL *) Acpi;
911 }
912
913 STATIC
914 EFI_DEVICE_PATH_PROTOCOL *
915 DevPathFromTextPciRoot (
916 IN CHAR16 *TextDeviceNode
917 )
918 {
919 return ConvertFromTextAcpi (TextDeviceNode, 0x0a0341d0);
920 }
921
922 STATIC
923 EFI_DEVICE_PATH_PROTOCOL *
924 DevPathFromTextFloppy (
925 IN CHAR16 *TextDeviceNode
926 )
927 {
928 return ConvertFromTextAcpi (TextDeviceNode, 0x060441d0);
929 }
930
931 STATIC
932 EFI_DEVICE_PATH_PROTOCOL *
933 DevPathFromTextKeyboard (
934 IN CHAR16 *TextDeviceNode
935 )
936 {
937 return ConvertFromTextAcpi (TextDeviceNode, 0x030141d0);
938 }
939
940 STATIC
941 EFI_DEVICE_PATH_PROTOCOL *
942 DevPathFromTextSerial (
943 IN CHAR16 *TextDeviceNode
944 )
945 {
946 return ConvertFromTextAcpi (TextDeviceNode, 0x050141d0);
947 }
948
949 STATIC
950 EFI_DEVICE_PATH_PROTOCOL *
951 DevPathFromTextParallelPort (
952 IN CHAR16 *TextDeviceNode
953 )
954 {
955 return ConvertFromTextAcpi (TextDeviceNode, 0x040141d0);
956 }
957
958 STATIC
959 EFI_DEVICE_PATH_PROTOCOL *
960 DevPathFromTextAcpiEx (
961 IN CHAR16 *TextDeviceNode
962 )
963 {
964 CHAR16 *HIDStr;
965 CHAR16 *CIDStr;
966 CHAR16 *UIDStr;
967 CHAR16 *HIDSTRStr;
968 CHAR16 *CIDSTRStr;
969 CHAR16 *UIDSTRStr;
970 CHAR8 *AsciiStr;
971 UINT16 Length;
972 ACPI_EXTENDED_HID_DEVICE_PATH_WITH_STR *AcpiExt;
973
974 HIDStr = GetNextParamStr (&TextDeviceNode);
975 CIDStr = GetNextParamStr (&TextDeviceNode);
976 UIDStr = GetNextParamStr (&TextDeviceNode);
977 HIDSTRStr = GetNextParamStr (&TextDeviceNode);
978 CIDSTRStr = GetNextParamStr (&TextDeviceNode);
979 UIDSTRStr = GetNextParamStr (&TextDeviceNode);
980
981 Length = (UINT16) (sizeof (ACPI_EXTENDED_HID_DEVICE_PATH) + StrLen (HIDSTRStr) + 1);
982 Length = (UINT16) (Length + StrLen (UIDSTRStr) + 1);
983 Length = (UINT16) (Length + StrLen (CIDSTRStr) + 1);
984 AcpiExt = (ACPI_EXTENDED_HID_DEVICE_PATH_WITH_STR *) CreateDeviceNode (
985 ACPI_DEVICE_PATH,
986 ACPI_EXTENDED_DP,
987 Length
988 );
989
990 if ((HIDStr[0] == L'P') && (HIDStr[1] == L'N') && (HIDStr[2] == L'P')) {
991 HIDStr += 3;
992 AcpiExt->HID = EISA_PNP_ID (Xtoi (HIDStr));
993 } else {
994 AcpiExt->HID = (UINT32) Xtoi (HIDStr);
995 }
996
997 AcpiExt->UID = (UINT32) Xtoi (UIDStr);
998 AcpiExt->CID = (UINT32) Xtoi (CIDStr);
999
1000 AsciiStr = AcpiExt->HidUidCidStr;
1001 StrToAscii (HIDSTRStr, &AsciiStr);
1002 StrToAscii (UIDSTRStr, &AsciiStr);
1003 StrToAscii (CIDSTRStr, &AsciiStr);
1004
1005 return (EFI_DEVICE_PATH_PROTOCOL *) AcpiExt;
1006 }
1007
1008 STATIC
1009 EFI_DEVICE_PATH_PROTOCOL *
1010 DevPathFromTextAcpiExp (
1011 IN CHAR16 *TextDeviceNode
1012 )
1013 {
1014 CHAR16 *HIDStr;
1015 CHAR16 *CIDStr;
1016 CHAR16 *UIDSTRStr;
1017 CHAR8 *AsciiStr;
1018 UINT16 Length;
1019 ACPI_EXTENDED_HID_DEVICE_PATH_WITH_STR *AcpiExt;
1020
1021 HIDStr = GetNextParamStr (&TextDeviceNode);
1022 CIDStr = GetNextParamStr (&TextDeviceNode);
1023 UIDSTRStr = GetNextParamStr (&TextDeviceNode);
1024 Length = sizeof (ACPI_EXTENDED_HID_DEVICE_PATH) + (UINT16) StrLen (UIDSTRStr) + 3;
1025 AcpiExt = (ACPI_EXTENDED_HID_DEVICE_PATH_WITH_STR *) CreateDeviceNode (
1026 ACPI_DEVICE_PATH,
1027 ACPI_EXTENDED_DP,
1028 Length
1029 );
1030
1031 if ((HIDStr[0] == L'P') && (HIDStr[1] == L'N') && (HIDStr[2] == L'P')) {
1032 HIDStr += 3;
1033 AcpiExt->HID = EISA_PNP_ID (Xtoi (HIDStr));
1034 } else {
1035 AcpiExt->HID = (UINT32) Xtoi (HIDStr);
1036 }
1037
1038 AcpiExt->UID = 0;
1039 AcpiExt->CID = (UINT32) Xtoi (CIDStr);
1040
1041 AsciiStr = AcpiExt->HidUidCidStr;
1042 //
1043 // HID string is NULL
1044 //
1045 *AsciiStr = 0;
1046 //
1047 // Convert UID string
1048 //
1049 AsciiStr++;
1050 StrToAscii (UIDSTRStr, &AsciiStr);
1051 //
1052 // CID string is NULL
1053 //
1054 *AsciiStr = 0;
1055
1056 return (EFI_DEVICE_PATH_PROTOCOL *) AcpiExt;
1057 }
1058
1059 STATIC
1060 EFI_DEVICE_PATH_PROTOCOL *
1061 DevPathFromTextAta (
1062 IN CHAR16 *TextDeviceNode
1063 )
1064 {
1065 CHAR16 *PrimarySecondaryStr;
1066 CHAR16 *SlaveMasterStr;
1067 CHAR16 *LunStr;
1068 ATAPI_DEVICE_PATH *Atapi;
1069
1070 Atapi = (ATAPI_DEVICE_PATH *) CreateDeviceNode (
1071 MESSAGING_DEVICE_PATH,
1072 MSG_ATAPI_DP,
1073 sizeof (ATAPI_DEVICE_PATH)
1074 );
1075
1076 PrimarySecondaryStr = GetNextParamStr (&TextDeviceNode);
1077 SlaveMasterStr = GetNextParamStr (&TextDeviceNode);
1078 LunStr = GetNextParamStr (&TextDeviceNode);
1079
1080 Atapi->PrimarySecondary = (UINT8) ((StrCmp (PrimarySecondaryStr, L"Primary") == 0) ? 0 : 1);
1081 Atapi->SlaveMaster = (UINT8) ((StrCmp (SlaveMasterStr, L"Master") == 0) ? 0 : 1);
1082 Atapi->Lun = (UINT16) Xtoi (LunStr);
1083
1084 return (EFI_DEVICE_PATH_PROTOCOL *) Atapi;
1085 }
1086
1087 STATIC
1088 EFI_DEVICE_PATH_PROTOCOL *
1089 DevPathFromTextScsi (
1090 IN CHAR16 *TextDeviceNode
1091 )
1092 {
1093 CHAR16 *PunStr;
1094 CHAR16 *LunStr;
1095 SCSI_DEVICE_PATH *Scsi;
1096
1097 PunStr = GetNextParamStr (&TextDeviceNode);
1098 LunStr = GetNextParamStr (&TextDeviceNode);
1099 Scsi = (SCSI_DEVICE_PATH *) CreateDeviceNode (
1100 MESSAGING_DEVICE_PATH,
1101 MSG_SCSI_DP,
1102 sizeof (SCSI_DEVICE_PATH)
1103 );
1104
1105 Scsi->Pun = (UINT16) Xtoi (PunStr);
1106 Scsi->Lun = (UINT16) Xtoi (LunStr);
1107
1108 return (EFI_DEVICE_PATH_PROTOCOL *) Scsi;
1109 }
1110
1111 STATIC
1112 EFI_DEVICE_PATH_PROTOCOL *
1113 DevPathFromTextFibre (
1114 IN CHAR16 *TextDeviceNode
1115 )
1116 {
1117 CHAR16 *WWNStr;
1118 CHAR16 *LunStr;
1119 FIBRECHANNEL_DEVICE_PATH *Fibre;
1120
1121 WWNStr = GetNextParamStr (&TextDeviceNode);
1122 LunStr = GetNextParamStr (&TextDeviceNode);
1123 Fibre = (FIBRECHANNEL_DEVICE_PATH *) CreateDeviceNode (
1124 MESSAGING_DEVICE_PATH,
1125 MSG_FIBRECHANNEL_DP,
1126 sizeof (FIBRECHANNEL_DEVICE_PATH)
1127 );
1128
1129 Fibre->Reserved = 0;
1130 Xtoi64 (WWNStr, &Fibre->WWN);
1131 Xtoi64 (LunStr, &Fibre->Lun);
1132
1133 return (EFI_DEVICE_PATH_PROTOCOL *) Fibre;
1134 }
1135
1136 STATIC
1137 EFI_DEVICE_PATH_PROTOCOL *
1138 DevPathFromText1394 (
1139 IN CHAR16 *TextDeviceNode
1140 )
1141 {
1142 CHAR16 *GuidStr;
1143 F1394_DEVICE_PATH *F1394;
1144
1145 GuidStr = GetNextParamStr (&TextDeviceNode);
1146 F1394 = (F1394_DEVICE_PATH *) CreateDeviceNode (
1147 MESSAGING_DEVICE_PATH,
1148 MSG_1394_DP,
1149 sizeof (F1394_DEVICE_PATH)
1150 );
1151
1152 F1394->Reserved = 0;
1153 Xtoi64 (GuidStr, &F1394->Guid);
1154
1155 return (EFI_DEVICE_PATH_PROTOCOL *) F1394;
1156 }
1157
1158 STATIC
1159 EFI_DEVICE_PATH_PROTOCOL *
1160 DevPathFromTextUsb (
1161 IN CHAR16 *TextDeviceNode
1162 )
1163 {
1164 CHAR16 *PortStr;
1165 CHAR16 *InterfaceStr;
1166 USB_DEVICE_PATH *Usb;
1167
1168 PortStr = GetNextParamStr (&TextDeviceNode);
1169 InterfaceStr = GetNextParamStr (&TextDeviceNode);
1170 Usb = (USB_DEVICE_PATH *) CreateDeviceNode (
1171 MESSAGING_DEVICE_PATH,
1172 MSG_USB_DP,
1173 sizeof (USB_DEVICE_PATH)
1174 );
1175
1176 Usb->ParentPortNumber = (UINT8) Xtoi (PortStr);
1177 Usb->InterfaceNumber = (UINT8) Xtoi (InterfaceStr);
1178
1179 return (EFI_DEVICE_PATH_PROTOCOL *) Usb;
1180 }
1181
1182 STATIC
1183 EFI_DEVICE_PATH_PROTOCOL *
1184 DevPathFromTextI2O (
1185 IN CHAR16 *TextDeviceNode
1186 )
1187 {
1188 CHAR16 *TIDStr;
1189 I2O_DEVICE_PATH *I2O;
1190
1191 TIDStr = GetNextParamStr (&TextDeviceNode);
1192 I2O = (I2O_DEVICE_PATH *) CreateDeviceNode (
1193 MESSAGING_DEVICE_PATH,
1194 MSG_I2O_DP,
1195 sizeof (I2O_DEVICE_PATH)
1196 );
1197
1198 I2O->Tid = (UINT32) Xtoi (TIDStr);
1199
1200 return (EFI_DEVICE_PATH_PROTOCOL *) I2O;
1201 }
1202
1203 STATIC
1204 EFI_DEVICE_PATH_PROTOCOL *
1205 DevPathFromTextInfiniband (
1206 IN CHAR16 *TextDeviceNode
1207 )
1208 {
1209 CHAR16 *FlagsStr;
1210 CHAR16 *GuidStr;
1211 CHAR16 *SidStr;
1212 CHAR16 *TidStr;
1213 CHAR16 *DidStr;
1214 EFI_GUID PortGid;
1215 INFINIBAND_DEVICE_PATH *InfiniBand;
1216
1217 FlagsStr = GetNextParamStr (&TextDeviceNode);
1218 GuidStr = GetNextParamStr (&TextDeviceNode);
1219 SidStr = GetNextParamStr (&TextDeviceNode);
1220 TidStr = GetNextParamStr (&TextDeviceNode);
1221 DidStr = GetNextParamStr (&TextDeviceNode);
1222 InfiniBand = (INFINIBAND_DEVICE_PATH *) CreateDeviceNode (
1223 MESSAGING_DEVICE_PATH,
1224 MSG_INFINIBAND_DP,
1225 sizeof (INFINIBAND_DEVICE_PATH)
1226 );
1227
1228 InfiniBand->ResourceFlags = (UINT32) Xtoi (FlagsStr);
1229 StrToGuid (GuidStr, &PortGid);
1230 CopyMem (InfiniBand->PortGid, &PortGid, sizeof (EFI_GUID));
1231 Xtoi64 (SidStr, &InfiniBand->ServiceId);
1232 Xtoi64 (TidStr, &InfiniBand->TargetPortId);
1233 Xtoi64 (DidStr, &InfiniBand->DeviceId);
1234
1235 return (EFI_DEVICE_PATH_PROTOCOL *) InfiniBand;
1236 }
1237
1238 STATIC
1239 EFI_DEVICE_PATH_PROTOCOL *
1240 DevPathFromTextVenMsg (
1241 IN CHAR16 *TextDeviceNode
1242 )
1243 {
1244 return ConvertFromTextVendor (
1245 TextDeviceNode,
1246 MESSAGING_DEVICE_PATH,
1247 MSG_VENDOR_DP
1248 );
1249 }
1250
1251 STATIC
1252 EFI_DEVICE_PATH_PROTOCOL *
1253 DevPathFromTextVenPcAnsi (
1254 IN CHAR16 *TextDeviceNode
1255 )
1256 {
1257 VENDOR_DEVICE_PATH *Vendor;
1258
1259 Vendor = (VENDOR_DEVICE_PATH *) CreateDeviceNode (
1260 MESSAGING_DEVICE_PATH,
1261 MSG_VENDOR_DP,
1262 sizeof (VENDOR_DEVICE_PATH));
1263 CopyGuid (&Vendor->Guid, &gEfiPcAnsiGuid);
1264
1265 return (EFI_DEVICE_PATH_PROTOCOL *) Vendor;
1266 }
1267
1268 STATIC
1269 EFI_DEVICE_PATH_PROTOCOL *
1270 DevPathFromTextVenVt100 (
1271 IN CHAR16 *TextDeviceNode
1272 )
1273 {
1274 VENDOR_DEVICE_PATH *Vendor;
1275
1276 Vendor = (VENDOR_DEVICE_PATH *) CreateDeviceNode (
1277 MESSAGING_DEVICE_PATH,
1278 MSG_VENDOR_DP,
1279 sizeof (VENDOR_DEVICE_PATH));
1280 CopyGuid (&Vendor->Guid, &gEfiVT100Guid);
1281
1282 return (EFI_DEVICE_PATH_PROTOCOL *) Vendor;
1283 }
1284
1285 STATIC
1286 EFI_DEVICE_PATH_PROTOCOL *
1287 DevPathFromTextVenVt100Plus (
1288 IN CHAR16 *TextDeviceNode
1289 )
1290 {
1291 VENDOR_DEVICE_PATH *Vendor;
1292
1293 Vendor = (VENDOR_DEVICE_PATH *) CreateDeviceNode (
1294 MESSAGING_DEVICE_PATH,
1295 MSG_VENDOR_DP,
1296 sizeof (VENDOR_DEVICE_PATH));
1297 CopyGuid (&Vendor->Guid, &gEfiVT100PlusGuid);
1298
1299 return (EFI_DEVICE_PATH_PROTOCOL *) Vendor;
1300 }
1301
1302 STATIC
1303 EFI_DEVICE_PATH_PROTOCOL *
1304 DevPathFromTextVenUtf8 (
1305 IN CHAR16 *TextDeviceNode
1306 )
1307 {
1308 VENDOR_DEVICE_PATH *Vendor;
1309
1310 Vendor = (VENDOR_DEVICE_PATH *) CreateDeviceNode (
1311 MESSAGING_DEVICE_PATH,
1312 MSG_VENDOR_DP,
1313 sizeof (VENDOR_DEVICE_PATH));
1314 CopyGuid (&Vendor->Guid, &gEfiVTUTF8Guid);
1315
1316 return (EFI_DEVICE_PATH_PROTOCOL *) Vendor;
1317 }
1318
1319 STATIC
1320 EFI_DEVICE_PATH_PROTOCOL *
1321 DevPathFromTextUartFlowCtrl (
1322 IN CHAR16 *TextDeviceNode
1323 )
1324 {
1325 CHAR16 *ValueStr;
1326 UART_FLOW_CONTROL_DEVICE_PATH *UartFlowControl;
1327
1328 ValueStr = GetNextParamStr (&TextDeviceNode);
1329 UartFlowControl = (UART_FLOW_CONTROL_DEVICE_PATH *) CreateDeviceNode (
1330 MESSAGING_DEVICE_PATH,
1331 MSG_VENDOR_DP,
1332 sizeof (UART_FLOW_CONTROL_DEVICE_PATH)
1333 );
1334
1335 CopyGuid (&UartFlowControl->Guid, &mEfiDevicePathMessagingUartFlowControlGuid);
1336 if (StrCmp (ValueStr, L"XonXoff") == 0) {
1337 UartFlowControl->FlowControlMap = 2;
1338 } else if (StrCmp (ValueStr, L"Hardware") == 0) {
1339 UartFlowControl->FlowControlMap = 1;
1340 } else {
1341 UartFlowControl->FlowControlMap = 0;
1342 }
1343
1344 return (EFI_DEVICE_PATH_PROTOCOL *) UartFlowControl;
1345 }
1346
1347 STATIC
1348 EFI_DEVICE_PATH_PROTOCOL *
1349 DevPathFromTextSAS (
1350 IN CHAR16 *TextDeviceNode
1351 )
1352 {
1353 CHAR16 *AddressStr;
1354 CHAR16 *LunStr;
1355 CHAR16 *RTPStr;
1356 CHAR16 *SASSATAStr;
1357 CHAR16 *LocationStr;
1358 CHAR16 *ConnectStr;
1359 CHAR16 *DriveBayStr;
1360 CHAR16 *ReservedStr;
1361 UINT16 Info;
1362 SAS_DEVICE_PATH *Sas;
1363
1364 AddressStr = GetNextParamStr (&TextDeviceNode);
1365 LunStr = GetNextParamStr (&TextDeviceNode);
1366 RTPStr = GetNextParamStr (&TextDeviceNode);
1367 SASSATAStr = GetNextParamStr (&TextDeviceNode);
1368 LocationStr = GetNextParamStr (&TextDeviceNode);
1369 ConnectStr = GetNextParamStr (&TextDeviceNode);
1370 DriveBayStr = GetNextParamStr (&TextDeviceNode);
1371 ReservedStr = GetNextParamStr (&TextDeviceNode);
1372 Info = 0x0000;
1373 Sas = (SAS_DEVICE_PATH *) CreateDeviceNode (
1374 MESSAGING_DEVICE_PATH,
1375 MSG_VENDOR_DP,
1376 sizeof (SAS_DEVICE_PATH)
1377 );
1378
1379 CopyGuid (&Sas->Guid, &mEfiDevicePathMessagingSASGuid);
1380 Xtoi64 (AddressStr, &Sas->SasAddress);
1381 Xtoi64 (LunStr, &Sas->Lun);
1382 Sas->RelativeTargetPort = (UINT16) Xtoi (RTPStr);
1383 if (StrCmp (SASSATAStr, L"NoTopology") == 0)
1384 ;
1385 else {
1386 if (StrCmp (DriveBayStr, L"0") == 0) {
1387 Info |= 0x0001;
1388 } else {
1389 Info |= 0x0002;
1390 Info |= (Xtoi (DriveBayStr) << 8);
1391 }
1392
1393 if (StrCmp (SASSATAStr, L"SATA") == 0) {
1394 Info |= 0x0010;
1395 }
1396
1397 if (StrCmp (LocationStr, L"External") == 0) {
1398 Info |= 0x0020;
1399 }
1400
1401 if (StrCmp (ConnectStr, L"Expanded") == 0) {
1402 Info |= 0x0040;
1403 }
1404 }
1405
1406 Sas->DeviceTopology = Info;
1407 Sas->Reserved = (UINT32) Xtoi (ReservedStr);
1408
1409 return (EFI_DEVICE_PATH_PROTOCOL *) Sas;
1410 }
1411
1412 STATIC
1413 EFI_DEVICE_PATH_PROTOCOL *
1414 DevPathFromTextDebugPort (
1415 IN CHAR16 *TextDeviceNode
1416 )
1417 {
1418 VENDOR_DEFINED_MESSAGING_DEVICE_PATH *Vend;
1419
1420 Vend = (VENDOR_DEFINED_MESSAGING_DEVICE_PATH *) CreateDeviceNode (
1421 MESSAGING_DEVICE_PATH,
1422 MSG_VENDOR_DP,
1423 sizeof (VENDOR_DEFINED_MESSAGING_DEVICE_PATH)
1424 );
1425
1426 CopyGuid (&Vend->Guid, &gEfiDebugPortProtocolGuid);
1427
1428 return (EFI_DEVICE_PATH_PROTOCOL *) Vend;
1429 }
1430
1431 STATIC
1432 EFI_DEVICE_PATH_PROTOCOL *
1433 DevPathFromTextMAC (
1434 IN CHAR16 *TextDeviceNode
1435 )
1436 {
1437 CHAR16 *AddressStr;
1438 CHAR16 *IfTypeStr;
1439 UINTN Length;
1440 MAC_ADDR_DEVICE_PATH *MAC;
1441
1442 AddressStr = GetNextParamStr (&TextDeviceNode);
1443 IfTypeStr = GetNextParamStr (&TextDeviceNode);
1444 MAC = (MAC_ADDR_DEVICE_PATH *) CreateDeviceNode (
1445 MESSAGING_DEVICE_PATH,
1446 MSG_MAC_ADDR_DP,
1447 sizeof (MAC_ADDR_DEVICE_PATH)
1448 );
1449
1450 MAC->IfType = (UINT8) Xtoi (IfTypeStr);
1451
1452 Length = sizeof (EFI_MAC_ADDRESS);
1453 StrToBuf (&MAC->MacAddress.Addr[0], Length, AddressStr);
1454
1455 return (EFI_DEVICE_PATH_PROTOCOL *) MAC;
1456 }
1457
1458 STATIC
1459 EFI_DEVICE_PATH_PROTOCOL *
1460 DevPathFromTextIPv4 (
1461 IN CHAR16 *TextDeviceNode
1462 )
1463 {
1464 CHAR16 *RemoteIPStr;
1465 CHAR16 *ProtocolStr;
1466 CHAR16 *TypeStr;
1467 CHAR16 *LocalIPStr;
1468 IPv4_DEVICE_PATH *IPv4;
1469
1470 RemoteIPStr = GetNextParamStr (&TextDeviceNode);
1471 ProtocolStr = GetNextParamStr (&TextDeviceNode);
1472 TypeStr = GetNextParamStr (&TextDeviceNode);
1473 LocalIPStr = GetNextParamStr (&TextDeviceNode);
1474 IPv4 = (IPv4_DEVICE_PATH *) CreateDeviceNode (
1475 MESSAGING_DEVICE_PATH,
1476 MSG_IPv4_DP,
1477 sizeof (IPv4_DEVICE_PATH)
1478 );
1479
1480 StrToIPv4Addr (&RemoteIPStr, &IPv4->RemoteIpAddress);
1481 IPv4->Protocol = (UINT16) ((StrCmp (ProtocolStr, L"UDP") == 0) ? 0 : 1);
1482 if (StrCmp (TypeStr, L"Static") == 0) {
1483 IPv4->StaticIpAddress = TRUE;
1484 } else {
1485 IPv4->StaticIpAddress = FALSE;
1486 }
1487
1488 StrToIPv4Addr (&LocalIPStr, &IPv4->LocalIpAddress);
1489
1490 IPv4->LocalPort = 0;
1491 IPv4->RemotePort = 0;
1492
1493 return (EFI_DEVICE_PATH_PROTOCOL *) IPv4;
1494 }
1495
1496 STATIC
1497 EFI_DEVICE_PATH_PROTOCOL *
1498 DevPathFromTextIPv6 (
1499 IN CHAR16 *TextDeviceNode
1500 )
1501 {
1502 CHAR16 *RemoteIPStr;
1503 CHAR16 *ProtocolStr;
1504 CHAR16 *TypeStr;
1505 CHAR16 *LocalIPStr;
1506 IPv6_DEVICE_PATH *IPv6;
1507
1508 RemoteIPStr = GetNextParamStr (&TextDeviceNode);
1509 ProtocolStr = GetNextParamStr (&TextDeviceNode);
1510 TypeStr = GetNextParamStr (&TextDeviceNode);
1511 LocalIPStr = GetNextParamStr (&TextDeviceNode);
1512 IPv6 = (IPv6_DEVICE_PATH *) CreateDeviceNode (
1513 MESSAGING_DEVICE_PATH,
1514 MSG_IPv6_DP,
1515 sizeof (IPv6_DEVICE_PATH)
1516 );
1517
1518 StrToIPv6Addr (&RemoteIPStr, &IPv6->RemoteIpAddress);
1519 IPv6->Protocol = (UINT16) ((StrCmp (ProtocolStr, L"UDP") == 0) ? 0 : 1);
1520 if (StrCmp (TypeStr, L"Static") == 0) {
1521 IPv6->StaticIpAddress = TRUE;
1522 } else {
1523 IPv6->StaticIpAddress = FALSE;
1524 }
1525
1526 StrToIPv6Addr (&LocalIPStr, &IPv6->LocalIpAddress);
1527
1528 IPv6->LocalPort = 0;
1529 IPv6->RemotePort = 0;
1530
1531 return (EFI_DEVICE_PATH_PROTOCOL *) IPv6;
1532 }
1533
1534 STATIC
1535 EFI_DEVICE_PATH_PROTOCOL *
1536 DevPathFromTextUart (
1537 IN CHAR16 *TextDeviceNode
1538 )
1539 {
1540 CHAR16 *BaudStr;
1541 CHAR16 *DataBitsStr;
1542 CHAR16 *ParityStr;
1543 CHAR16 *StopBitsStr;
1544 UART_DEVICE_PATH *Uart;
1545
1546 BaudStr = GetNextParamStr (&TextDeviceNode);
1547 DataBitsStr = GetNextParamStr (&TextDeviceNode);
1548 ParityStr = GetNextParamStr (&TextDeviceNode);
1549 StopBitsStr = GetNextParamStr (&TextDeviceNode);
1550 Uart = (UART_DEVICE_PATH *) CreateDeviceNode (
1551 MESSAGING_DEVICE_PATH,
1552 MSG_UART_DP,
1553 sizeof (UART_DEVICE_PATH)
1554 );
1555
1556 Uart->BaudRate = (StrCmp (BaudStr, L"DEFAULT") == 0) ? 115200 : Atoi (BaudStr);
1557 Uart->DataBits = (UINT8) ((StrCmp (DataBitsStr, L"DEFAULT") == 0) ? 8 : Atoi (DataBitsStr));
1558 switch (*ParityStr) {
1559 case L'D':
1560 Uart->Parity = 0;
1561 break;
1562
1563 case L'N':
1564 Uart->Parity = 1;
1565 break;
1566
1567 case L'E':
1568 Uart->Parity = 2;
1569 break;
1570
1571 case L'O':
1572 Uart->Parity = 3;
1573 break;
1574
1575 case L'M':
1576 Uart->Parity = 4;
1577 break;
1578
1579 case L'S':
1580 Uart->Parity = 5;
1581
1582 default:
1583 Uart->Parity = 0xff;
1584 }
1585
1586 if (StrCmp (StopBitsStr, L"D") == 0) {
1587 Uart->StopBits = (UINT8) 0;
1588 } else if (StrCmp (StopBitsStr, L"1") == 0) {
1589 Uart->StopBits = (UINT8) 1;
1590 } else if (StrCmp (StopBitsStr, L"1.5") == 0) {
1591 Uart->StopBits = (UINT8) 2;
1592 } else if (StrCmp (StopBitsStr, L"2") == 0) {
1593 Uart->StopBits = (UINT8) 3;
1594 } else {
1595 Uart->StopBits = 0xff;
1596 }
1597
1598 return (EFI_DEVICE_PATH_PROTOCOL *) Uart;
1599 }
1600
1601 STATIC
1602 EFI_DEVICE_PATH_PROTOCOL *
1603 ConvertFromTextUsbClass (
1604 IN CHAR16 *TextDeviceNode,
1605 IN USB_CLASS_TEXT *UsbClassText
1606 )
1607 {
1608 CHAR16 *VIDStr;
1609 CHAR16 *PIDStr;
1610 CHAR16 *ClassStr;
1611 CHAR16 *SubClassStr;
1612 CHAR16 *ProtocolStr;
1613 USB_CLASS_DEVICE_PATH *UsbClass;
1614
1615 UsbClass = (USB_CLASS_DEVICE_PATH *) CreateDeviceNode (
1616 MESSAGING_DEVICE_PATH,
1617 MSG_USB_CLASS_DP,
1618 sizeof (USB_CLASS_DEVICE_PATH)
1619 );
1620
1621 VIDStr = GetNextParamStr (&TextDeviceNode);
1622 PIDStr = GetNextParamStr (&TextDeviceNode);
1623 if (UsbClassText->ClassExist) {
1624 ClassStr = GetNextParamStr (&TextDeviceNode);
1625 UsbClass->DeviceClass = (UINT8) Xtoi (ClassStr);
1626 } else {
1627 UsbClass->DeviceClass = UsbClassText->Class;
1628 }
1629 if (UsbClassText->SubClassExist) {
1630 SubClassStr = GetNextParamStr (&TextDeviceNode);
1631 UsbClass->DeviceSubClass = (UINT8) Xtoi (SubClassStr);
1632 } else {
1633 UsbClass->DeviceSubClass = UsbClassText->SubClass;
1634 }
1635
1636 ProtocolStr = GetNextParamStr (&TextDeviceNode);
1637
1638 UsbClass->VendorId = (UINT16) Xtoi (VIDStr);
1639 UsbClass->ProductId = (UINT16) Xtoi (PIDStr);
1640 UsbClass->DeviceProtocol = (UINT8) Xtoi (ProtocolStr);
1641
1642 return (EFI_DEVICE_PATH_PROTOCOL *) UsbClass;
1643 }
1644
1645
1646 STATIC
1647 EFI_DEVICE_PATH_PROTOCOL *
1648 DevPathFromTextUsbClass (
1649 IN CHAR16 *TextDeviceNode
1650 )
1651 {
1652 USB_CLASS_TEXT UsbClassText;
1653
1654 UsbClassText.ClassExist = TRUE;
1655 UsbClassText.SubClassExist = TRUE;
1656
1657 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1658 }
1659
1660 STATIC
1661 EFI_DEVICE_PATH_PROTOCOL *
1662 DevPathFromTextUsbAudio (
1663 IN CHAR16 *TextDeviceNode
1664 )
1665 {
1666 USB_CLASS_TEXT UsbClassText;
1667
1668 UsbClassText.ClassExist = FALSE;
1669 UsbClassText.Class = USB_CLASS_AUDIO;
1670 UsbClassText.SubClassExist = TRUE;
1671
1672 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1673 }
1674
1675 STATIC
1676 EFI_DEVICE_PATH_PROTOCOL *
1677 DevPathFromTextUsbCDCControl (
1678 IN CHAR16 *TextDeviceNode
1679 )
1680 {
1681 USB_CLASS_TEXT UsbClassText;
1682
1683 UsbClassText.ClassExist = FALSE;
1684 UsbClassText.Class = USB_CLASS_CDCCONTROL;
1685 UsbClassText.SubClassExist = TRUE;
1686
1687 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1688 }
1689
1690 STATIC
1691 EFI_DEVICE_PATH_PROTOCOL *
1692 DevPathFromTextUsbHID (
1693 IN CHAR16 *TextDeviceNode
1694 )
1695 {
1696 USB_CLASS_TEXT UsbClassText;
1697
1698 UsbClassText.ClassExist = FALSE;
1699 UsbClassText.Class = USB_CLASS_HID;
1700 UsbClassText.SubClassExist = TRUE;
1701
1702 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1703 }
1704
1705 STATIC
1706 EFI_DEVICE_PATH_PROTOCOL *
1707 DevPathFromTextUsbImage (
1708 IN CHAR16 *TextDeviceNode
1709 )
1710 {
1711 USB_CLASS_TEXT UsbClassText;
1712
1713 UsbClassText.ClassExist = FALSE;
1714 UsbClassText.Class = USB_CLASS_IMAGE;
1715 UsbClassText.SubClassExist = TRUE;
1716
1717 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1718 }
1719
1720 STATIC
1721 EFI_DEVICE_PATH_PROTOCOL *
1722 DevPathFromTextUsbPrinter (
1723 IN CHAR16 *TextDeviceNode
1724 )
1725 {
1726 USB_CLASS_TEXT UsbClassText;
1727
1728 UsbClassText.ClassExist = FALSE;
1729 UsbClassText.Class = USB_CLASS_PRINTER;
1730 UsbClassText.SubClassExist = TRUE;
1731
1732 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1733 }
1734
1735 STATIC
1736 EFI_DEVICE_PATH_PROTOCOL *
1737 DevPathFromTextUsbMassStorage (
1738 IN CHAR16 *TextDeviceNode
1739 )
1740 {
1741 USB_CLASS_TEXT UsbClassText;
1742
1743 UsbClassText.ClassExist = FALSE;
1744 UsbClassText.Class = USB_CLASS_MASS_STORAGE;
1745 UsbClassText.SubClassExist = TRUE;
1746
1747 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1748 }
1749
1750 STATIC
1751 EFI_DEVICE_PATH_PROTOCOL *
1752 DevPathFromTextUsbHub (
1753 IN CHAR16 *TextDeviceNode
1754 )
1755 {
1756 USB_CLASS_TEXT UsbClassText;
1757
1758 UsbClassText.ClassExist = FALSE;
1759 UsbClassText.Class = USB_CLASS_HUB;
1760 UsbClassText.SubClassExist = TRUE;
1761
1762 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1763 }
1764
1765 STATIC
1766 EFI_DEVICE_PATH_PROTOCOL *
1767 DevPathFromTextUsbCDCData (
1768 IN CHAR16 *TextDeviceNode
1769 )
1770 {
1771 USB_CLASS_TEXT UsbClassText;
1772
1773 UsbClassText.ClassExist = FALSE;
1774 UsbClassText.Class = USB_CLASS_CDCDATA;
1775 UsbClassText.SubClassExist = TRUE;
1776
1777 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1778 }
1779
1780 STATIC
1781 EFI_DEVICE_PATH_PROTOCOL *
1782 DevPathFromTextUsbSmartCard (
1783 IN CHAR16 *TextDeviceNode
1784 )
1785 {
1786 USB_CLASS_TEXT UsbClassText;
1787
1788 UsbClassText.ClassExist = FALSE;
1789 UsbClassText.Class = USB_CLASS_SMART_CARD;
1790 UsbClassText.SubClassExist = TRUE;
1791
1792 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1793 }
1794
1795 STATIC
1796 EFI_DEVICE_PATH_PROTOCOL *
1797 DevPathFromTextUsbVideo (
1798 IN CHAR16 *TextDeviceNode
1799 )
1800 {
1801 USB_CLASS_TEXT UsbClassText;
1802
1803 UsbClassText.ClassExist = FALSE;
1804 UsbClassText.Class = USB_CLASS_VIDEO;
1805 UsbClassText.SubClassExist = TRUE;
1806
1807 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1808 }
1809
1810 STATIC
1811 EFI_DEVICE_PATH_PROTOCOL *
1812 DevPathFromTextUsbDiagnostic (
1813 IN CHAR16 *TextDeviceNode
1814 )
1815 {
1816 USB_CLASS_TEXT UsbClassText;
1817
1818 UsbClassText.ClassExist = FALSE;
1819 UsbClassText.Class = USB_CLASS_DIAGNOSTIC;
1820 UsbClassText.SubClassExist = TRUE;
1821
1822 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1823 }
1824
1825 STATIC
1826 EFI_DEVICE_PATH_PROTOCOL *
1827 DevPathFromTextUsbWireless (
1828 IN CHAR16 *TextDeviceNode
1829 )
1830 {
1831 USB_CLASS_TEXT UsbClassText;
1832
1833 UsbClassText.ClassExist = FALSE;
1834 UsbClassText.Class = USB_CLASS_WIRELESS;
1835 UsbClassText.SubClassExist = TRUE;
1836
1837 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1838 }
1839
1840 STATIC
1841 EFI_DEVICE_PATH_PROTOCOL *
1842 DevPathFromTextUsbDeviceFirmwareUpdate (
1843 IN CHAR16 *TextDeviceNode
1844 )
1845 {
1846 USB_CLASS_TEXT UsbClassText;
1847
1848 UsbClassText.ClassExist = FALSE;
1849 UsbClassText.Class = USB_CLASS_RESERVE;
1850 UsbClassText.SubClassExist = FALSE;
1851 UsbClassText.SubClass = USB_SUBCLASS_FW_UPDATE;
1852
1853 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1854 }
1855
1856 STATIC
1857 EFI_DEVICE_PATH_PROTOCOL *
1858 DevPathFromTextUsbIrdaBridge (
1859 IN CHAR16 *TextDeviceNode
1860 )
1861 {
1862 USB_CLASS_TEXT UsbClassText;
1863
1864 UsbClassText.ClassExist = FALSE;
1865 UsbClassText.Class = USB_CLASS_RESERVE;
1866 UsbClassText.SubClassExist = FALSE;
1867 UsbClassText.SubClass = USB_SUBCLASS_IRDA_BRIDGE;
1868
1869 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1870 }
1871
1872 STATIC
1873 EFI_DEVICE_PATH_PROTOCOL *
1874 DevPathFromTextUsbTestAndMeasurement (
1875 IN CHAR16 *TextDeviceNode
1876 )
1877 {
1878 USB_CLASS_TEXT UsbClassText;
1879
1880 UsbClassText.ClassExist = FALSE;
1881 UsbClassText.Class = USB_CLASS_RESERVE;
1882 UsbClassText.SubClassExist = FALSE;
1883 UsbClassText.SubClass = USB_SUBCLASS_TEST;
1884
1885 return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1886 }
1887
1888 STATIC
1889 EFI_DEVICE_PATH_PROTOCOL *
1890 DevPathFromTextUsbWwid (
1891 IN CHAR16 *TextDeviceNode
1892 )
1893 {
1894 CHAR16 *VIDStr;
1895 CHAR16 *PIDStr;
1896 CHAR16 *InterfaceNumStr;
1897 USB_WWID_DEVICE_PATH *UsbWwid;
1898
1899 VIDStr = GetNextParamStr (&TextDeviceNode);
1900 PIDStr = GetNextParamStr (&TextDeviceNode);
1901 InterfaceNumStr = GetNextParamStr (&TextDeviceNode);
1902 UsbWwid = (USB_WWID_DEVICE_PATH *) CreateDeviceNode (
1903 MESSAGING_DEVICE_PATH,
1904 MSG_USB_WWID_DP,
1905 sizeof (USB_WWID_DEVICE_PATH)
1906 );
1907
1908 UsbWwid->VendorId = (UINT16) Xtoi (VIDStr);
1909 UsbWwid->ProductId = (UINT16) Xtoi (PIDStr);
1910 UsbWwid->InterfaceNumber = (UINT16) Xtoi (InterfaceNumStr);
1911
1912 return (EFI_DEVICE_PATH_PROTOCOL *) UsbWwid;
1913 }
1914
1915 STATIC
1916 EFI_DEVICE_PATH_PROTOCOL *
1917 DevPathFromTextUnit (
1918 IN CHAR16 *TextDeviceNode
1919 )
1920 {
1921 CHAR16 *LunStr;
1922 DEVICE_LOGICAL_UNIT_DEVICE_PATH *LogicalUnit;
1923
1924 LunStr = GetNextParamStr (&TextDeviceNode);
1925 LogicalUnit = (DEVICE_LOGICAL_UNIT_DEVICE_PATH *) CreateDeviceNode (
1926 MESSAGING_DEVICE_PATH,
1927 MSG_DEVICE_LOGICAL_UNIT_DP,
1928 sizeof (DEVICE_LOGICAL_UNIT_DEVICE_PATH)
1929 );
1930
1931 LogicalUnit->Lun = (UINT8) Xtoi (LunStr);
1932
1933 return (EFI_DEVICE_PATH_PROTOCOL *) LogicalUnit;
1934 }
1935
1936 STATIC
1937 EFI_DEVICE_PATH_PROTOCOL *
1938 DevPathFromTextiSCSI (
1939 IN CHAR16 *TextDeviceNode
1940 )
1941 {
1942 UINT16 Options;
1943 CHAR16 *NameStr;
1944 CHAR16 *PortalGroupStr;
1945 CHAR16 *LunStr;
1946 CHAR16 *HeaderDigestStr;
1947 CHAR16 *DataDigestStr;
1948 CHAR16 *AuthenticationStr;
1949 CHAR16 *ProtocolStr;
1950 ISCSI_DEVICE_PATH_WITH_NAME *iSCSI;
1951
1952 NameStr = GetNextParamStr (&TextDeviceNode);
1953 PortalGroupStr = GetNextParamStr (&TextDeviceNode);
1954 LunStr = GetNextParamStr (&TextDeviceNode);
1955 HeaderDigestStr = GetNextParamStr (&TextDeviceNode);
1956 DataDigestStr = GetNextParamStr (&TextDeviceNode);
1957 AuthenticationStr = GetNextParamStr (&TextDeviceNode);
1958 ProtocolStr = GetNextParamStr (&TextDeviceNode);
1959 iSCSI = (ISCSI_DEVICE_PATH_WITH_NAME *) CreateDeviceNode (
1960 MESSAGING_DEVICE_PATH,
1961 MSG_ISCSI_DP,
1962 sizeof (ISCSI_DEVICE_PATH_WITH_NAME) + (UINT16) (StrLen (NameStr) * 2)
1963 );
1964
1965 StrCpy (iSCSI->iSCSITargetName, NameStr);
1966 iSCSI->TargetPortalGroupTag = (UINT16) Xtoi (PortalGroupStr);
1967 Xtoi64 (LunStr, &iSCSI->Lun);
1968
1969 Options = 0x0000;
1970 if (StrCmp (HeaderDigestStr, L"CRC32C") == 0) {
1971 Options |= 0x0002;
1972 }
1973
1974 if (StrCmp (DataDigestStr, L"CRC32C") == 0) {
1975 Options |= 0x0008;
1976 }
1977
1978 if (StrCmp (AuthenticationStr, L"None") == 0) {
1979 Options |= 0x0800;
1980 }
1981
1982 if (StrCmp (AuthenticationStr, L"CHAP_UNI") == 0) {
1983 Options |= 0x1000;
1984 }
1985
1986 iSCSI->LoginOption = (UINT16) Options;
1987
1988 iSCSI->NetworkProtocol = (UINT16) StrCmp (ProtocolStr, L"TCP");
1989 iSCSI->Reserved = (UINT16) 0;
1990
1991 return (EFI_DEVICE_PATH_PROTOCOL *) iSCSI;
1992 }
1993
1994 STATIC
1995 EFI_DEVICE_PATH_PROTOCOL *
1996 DevPathFromTextHD (
1997 IN CHAR16 *TextDeviceNode
1998 )
1999 {
2000 CHAR16 *PartitionStr;
2001 CHAR16 *TypeStr;
2002 CHAR16 *SignatureStr;
2003 CHAR16 *StartStr;
2004 CHAR16 *SizeStr;
2005 UINT32 Signature32;
2006 EFI_GUID SignatureGuid;
2007 HARDDRIVE_DEVICE_PATH *Hd;
2008
2009 PartitionStr = GetNextParamStr (&TextDeviceNode);
2010 TypeStr = GetNextParamStr (&TextDeviceNode);
2011 SignatureStr = GetNextParamStr (&TextDeviceNode);
2012 StartStr = GetNextParamStr (&TextDeviceNode);
2013 SizeStr = GetNextParamStr (&TextDeviceNode);
2014 Hd = (HARDDRIVE_DEVICE_PATH *) CreateDeviceNode (
2015 MEDIA_DEVICE_PATH,
2016 MEDIA_HARDDRIVE_DP,
2017 sizeof (HARDDRIVE_DEVICE_PATH)
2018 );
2019
2020 Hd->PartitionNumber = (UINT32) Atoi (PartitionStr);
2021
2022 ZeroMem (Hd->Signature, 16);
2023 Hd->MBRType = (UINT8) 0;
2024
2025 if (StrCmp (TypeStr, L"None") == 0) {
2026 Hd->SignatureType = (UINT8) 0;
2027 } else if (StrCmp (TypeStr, L"MBR") == 0) {
2028 Hd->SignatureType = SIGNATURE_TYPE_MBR;
2029 Hd->MBRType = 0x01;
2030
2031 Signature32 = (UINT32) Xtoi (SignatureStr);
2032 CopyMem (Hd->Signature, &Signature32, sizeof (UINT32));
2033 } else if (StrCmp (TypeStr, L"GUID") == 0) {
2034 Hd->SignatureType = SIGNATURE_TYPE_GUID;
2035 Hd->MBRType = 0x02;
2036
2037 StrToGuid (SignatureStr, &SignatureGuid);
2038 CopyMem (Hd->Signature, &SignatureGuid, sizeof (EFI_GUID));
2039 } else {
2040 Hd->SignatureType = 0xff;
2041
2042 }
2043
2044 Xtoi64 (StartStr, &Hd->PartitionStart);
2045 Xtoi64 (SizeStr, &Hd->PartitionSize);
2046
2047 return (EFI_DEVICE_PATH_PROTOCOL *) Hd;
2048 }
2049
2050 STATIC
2051 EFI_DEVICE_PATH_PROTOCOL *
2052 DevPathFromTextCDROM (
2053 IN CHAR16 *TextDeviceNode
2054 )
2055 {
2056 CHAR16 *EntryStr;
2057 CHAR16 *StartStr;
2058 CHAR16 *SizeStr;
2059 CDROM_DEVICE_PATH *CDROM;
2060
2061 EntryStr = GetNextParamStr (&TextDeviceNode);
2062 StartStr = GetNextParamStr (&TextDeviceNode);
2063 SizeStr = GetNextParamStr (&TextDeviceNode);
2064 CDROM = (CDROM_DEVICE_PATH *) CreateDeviceNode (
2065 MEDIA_DEVICE_PATH,
2066 MEDIA_CDROM_DP,
2067 sizeof (CDROM_DEVICE_PATH)
2068 );
2069
2070 CDROM->BootEntry = (UINT32) Xtoi (EntryStr);
2071 Xtoi64 (StartStr, &CDROM->PartitionStart);
2072 Xtoi64 (SizeStr, &CDROM->PartitionSize);
2073
2074 return (EFI_DEVICE_PATH_PROTOCOL *) CDROM;
2075 }
2076
2077 STATIC
2078 EFI_DEVICE_PATH_PROTOCOL *
2079 DevPathFromTextVenMEDIA (
2080 IN CHAR16 *TextDeviceNode
2081 )
2082 {
2083 return ConvertFromTextVendor (
2084 TextDeviceNode,
2085 MEDIA_DEVICE_PATH,
2086 MEDIA_VENDOR_DP
2087 );
2088 }
2089
2090 STATIC
2091 EFI_DEVICE_PATH_PROTOCOL *
2092 DevPathFromTextFilePath (
2093 IN CHAR16 *TextDeviceNode
2094 )
2095 {
2096 FILEPATH_DEVICE_PATH *File;
2097
2098 File = (FILEPATH_DEVICE_PATH *) CreateDeviceNode (
2099 MEDIA_DEVICE_PATH,
2100 MEDIA_FILEPATH_DP,
2101 sizeof (FILEPATH_DEVICE_PATH) + (UINT16) (StrLen (TextDeviceNode) * 2)
2102 );
2103
2104 StrCpy (File->PathName, TextDeviceNode);
2105
2106 return (EFI_DEVICE_PATH_PROTOCOL *) File;
2107 }
2108
2109 STATIC
2110 EFI_DEVICE_PATH_PROTOCOL *
2111 DevPathFromTextMedia (
2112 IN CHAR16 *TextDeviceNode
2113 )
2114 {
2115 CHAR16 *GuidStr;
2116 MEDIA_PROTOCOL_DEVICE_PATH *Media;
2117
2118 GuidStr = GetNextParamStr (&TextDeviceNode);
2119 Media = (MEDIA_PROTOCOL_DEVICE_PATH *) CreateDeviceNode (
2120 MEDIA_DEVICE_PATH,
2121 MEDIA_PROTOCOL_DP,
2122 sizeof (MEDIA_PROTOCOL_DEVICE_PATH)
2123 );
2124
2125 StrToGuid (GuidStr, &Media->Protocol);
2126
2127 return (EFI_DEVICE_PATH_PROTOCOL *) Media;
2128 }
2129
2130 STATIC
2131 EFI_DEVICE_PATH_PROTOCOL *
2132 DevPathFromTextBBS (
2133 IN CHAR16 *TextDeviceNode
2134 )
2135 {
2136 CHAR16 *TypeStr;
2137 CHAR16 *IdStr;
2138 CHAR16 *FlagsStr;
2139 UINT8 *AsciiStr;
2140 BBS_BBS_DEVICE_PATH *Bbs;
2141
2142 TypeStr = GetNextParamStr (&TextDeviceNode);
2143 IdStr = GetNextParamStr (&TextDeviceNode);
2144 FlagsStr = GetNextParamStr (&TextDeviceNode);
2145 Bbs = (BBS_BBS_DEVICE_PATH *) CreateDeviceNode (
2146 BBS_DEVICE_PATH,
2147 BBS_BBS_DP,
2148 sizeof (BBS_BBS_DEVICE_PATH) + (UINT16) (StrLen (IdStr))
2149 );
2150
2151 if (StrCmp (TypeStr, L"Floppy") == 0) {
2152 Bbs->DeviceType = BBS_TYPE_FLOPPY;
2153 } else if (StrCmp (TypeStr, L"HD") == 0) {
2154 Bbs->DeviceType = BBS_TYPE_HARDDRIVE;
2155 } else if (StrCmp (TypeStr, L"CDROM") == 0) {
2156 Bbs->DeviceType = BBS_TYPE_CDROM;
2157 } else if (StrCmp (TypeStr, L"PCMCIA") == 0) {
2158 Bbs->DeviceType = BBS_TYPE_PCMCIA;
2159 } else if (StrCmp (TypeStr, L"USB") == 0) {
2160 Bbs->DeviceType = BBS_TYPE_USB;
2161 } else if (StrCmp (TypeStr, L"Network") == 0) {
2162 Bbs->DeviceType = BBS_TYPE_EMBEDDED_NETWORK;
2163 } else {
2164 Bbs->DeviceType = BBS_TYPE_UNKNOWN;
2165 }
2166
2167 AsciiStr = (UINT8 *) Bbs->String;
2168 StrToAscii (IdStr, (CHAR8 **) &AsciiStr);
2169
2170 Bbs->StatusFlag = (UINT16) Xtoi (FlagsStr);
2171
2172 return (EFI_DEVICE_PATH_PROTOCOL *) Bbs;
2173 }
2174
2175 GLOBAL_REMOVE_IF_UNREFERENCED DEVICE_PATH_FROM_TEXT_TABLE DevPathFromTextTable[] = {
2176 {L"Pci", DevPathFromTextPci},
2177 {L"PcCard", DevPathFromTextPcCard},
2178 {L"MemoryMapped", DevPathFromTextMemoryMapped},
2179 {L"VenHw", DevPathFromTextVenHw},
2180 {L"Ctrl", DevPathFromTextCtrl},
2181 {L"Acpi", DevPathFromTextAcpi},
2182 {L"PciRoot", DevPathFromTextPciRoot},
2183 {L"Floppy", DevPathFromTextFloppy},
2184 {L"Keyboard", DevPathFromTextKeyboard},
2185 {L"Serial", DevPathFromTextSerial},
2186 {L"ParallelPort", DevPathFromTextParallelPort},
2187 {L"AcpiEx", DevPathFromTextAcpiEx},
2188 {L"AcpiExp", DevPathFromTextAcpiExp},
2189 {L"Ata", DevPathFromTextAta},
2190 {L"Scsi", DevPathFromTextScsi},
2191 {L"Fibre", DevPathFromTextFibre},
2192 {L"I1394", DevPathFromText1394},
2193 {L"USB", DevPathFromTextUsb},
2194 {L"I2O", DevPathFromTextI2O},
2195 {L"Infiniband", DevPathFromTextInfiniband},
2196 {L"VenMsg", DevPathFromTextVenMsg},
2197 {L"VenPcAnsi", DevPathFromTextVenPcAnsi},
2198 {L"VenVt100", DevPathFromTextVenVt100},
2199 {L"VenVt100Plus", DevPathFromTextVenVt100Plus},
2200 {L"VenUtf8", DevPathFromTextVenUtf8},
2201 {L"UartFlowCtrl", DevPathFromTextUartFlowCtrl},
2202 {L"SAS", DevPathFromTextSAS},
2203 {L"DebugPort", DevPathFromTextDebugPort},
2204 {L"MAC", DevPathFromTextMAC},
2205 {L"IPv4", DevPathFromTextIPv4},
2206 {L"IPv6", DevPathFromTextIPv6},
2207 {L"Uart", DevPathFromTextUart},
2208 {L"UsbClass", DevPathFromTextUsbClass},
2209 {L"UsbAudio", DevPathFromTextUsbAudio},
2210 {L"UsbCDCControl", DevPathFromTextUsbCDCControl},
2211 {L"UsbHID", DevPathFromTextUsbHID},
2212 {L"UsbImage", DevPathFromTextUsbImage},
2213 {L"UsbPrinter", DevPathFromTextUsbPrinter},
2214 {L"UsbMassStorage", DevPathFromTextUsbMassStorage},
2215 {L"UsbHub", DevPathFromTextUsbHub},
2216 {L"UsbCDCData", DevPathFromTextUsbCDCData},
2217 {L"UsbSmartCard", DevPathFromTextUsbSmartCard},
2218 {L"UsbVideo", DevPathFromTextUsbVideo},
2219 {L"UsbDiagnostic", DevPathFromTextUsbDiagnostic},
2220 {L"UsbWireless", DevPathFromTextUsbWireless},
2221 {L"UsbDeviceFirmwareUpdate", DevPathFromTextUsbDeviceFirmwareUpdate},
2222 {L"UsbIrdaBridge", DevPathFromTextUsbIrdaBridge},
2223 {L"UsbTestAndMeasurement", DevPathFromTextUsbTestAndMeasurement},
2224 {L"UsbWwid", DevPathFromTextUsbWwid},
2225 {L"Unit", DevPathFromTextUnit},
2226 {L"iSCSI", DevPathFromTextiSCSI},
2227 {L"HD", DevPathFromTextHD},
2228 {L"CDROM", DevPathFromTextCDROM},
2229 {L"VenMEDIA", DevPathFromTextVenMEDIA},
2230 {L"Media", DevPathFromTextMedia},
2231 {L"BBS", DevPathFromTextBBS},
2232 {NULL, NULL}
2233 };
2234
2235 EFI_DEVICE_PATH_PROTOCOL *
2236 ConvertTextToDeviceNode (
2237 IN CONST CHAR16 *TextDeviceNode
2238 )
2239 /*++
2240
2241 Routine Description:
2242 Convert text to the binary representation of a device node.
2243
2244 Arguments:
2245 TextDeviceNode - TextDeviceNode points to the text representation of a device
2246 node. Conversion starts with the first character and continues
2247 until the first non-device node character.
2248
2249 Returns:
2250 A pointer - Pointer to the EFI device node.
2251 NULL - If TextDeviceNode is NULL or there was insufficient memory or text unsupported.
2252
2253 --*/
2254 {
2255 EFI_DEVICE_PATH_PROTOCOL * (*DumpNode) (CHAR16 *);
2256 CHAR16 *ParamStr;
2257 EFI_DEVICE_PATH_PROTOCOL *DeviceNode;
2258 CHAR16 *DeviceNodeStr;
2259 UINTN Index;
2260
2261 if ((TextDeviceNode == NULL) || (IS_NULL (*TextDeviceNode))) {
2262 return NULL;
2263 }
2264
2265 ParamStr = NULL;
2266 DumpNode = NULL;
2267 DeviceNodeStr = StrDuplicate (TextDeviceNode);
2268
2269 for (Index = 0; DevPathFromTextTable[Index].Function; Index++) {
2270 ParamStr = GetParamByNodeName (DeviceNodeStr, DevPathFromTextTable[Index].DevicePathNodeText);
2271 if (ParamStr != NULL) {
2272 DumpNode = DevPathFromTextTable[Index].Function;
2273 break;
2274 }
2275 }
2276
2277 if (DumpNode == NULL) {
2278 //
2279 // A file path
2280 //
2281 DumpNode = DevPathFromTextFilePath;
2282 DeviceNode = DumpNode (DeviceNodeStr);
2283 } else {
2284 DeviceNode = DumpNode (ParamStr);
2285 FreePool (ParamStr);
2286 }
2287
2288 FreePool (DeviceNodeStr);
2289
2290 return DeviceNode;
2291 }
2292
2293 EFI_DEVICE_PATH_PROTOCOL *
2294 ConvertTextToDevicePath (
2295 IN CONST CHAR16 *TextDevicePath
2296 )
2297 /*++
2298
2299 Routine Description:
2300 Convert text to the binary representation of a device path.
2301
2302 Arguments:
2303 TextDevicePath - TextDevicePath points to the text representation of a device
2304 path. Conversion starts with the first character and continues
2305 until the first non-device node character.
2306
2307 Returns:
2308 A pointer - Pointer to the allocated device path.
2309 NULL - If TextDeviceNode is NULL or there was insufficient memory.
2310
2311 --*/
2312 {
2313 EFI_DEVICE_PATH_PROTOCOL * (*DumpNode) (CHAR16 *);
2314 CHAR16 *ParamStr;
2315 EFI_DEVICE_PATH_PROTOCOL *DeviceNode;
2316 UINTN Index;
2317 EFI_DEVICE_PATH_PROTOCOL *NewDevicePath;
2318 CHAR16 *DevicePathStr;
2319 CHAR16 *Str;
2320 CHAR16 *DeviceNodeStr;
2321 UINT8 IsInstanceEnd;
2322 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
2323
2324 if ((TextDevicePath == NULL) || (IS_NULL (*TextDevicePath))) {
2325 return NULL;
2326 }
2327
2328 DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) AllocatePool (END_DEVICE_PATH_LENGTH);
2329 SetDevicePathEndNode (DevicePath);
2330
2331 ParamStr = NULL;
2332 DeviceNodeStr = NULL;
2333 DevicePathStr = StrDuplicate (TextDevicePath);
2334
2335 Str = DevicePathStr;
2336 while ((DeviceNodeStr = GetNextDeviceNodeStr (&Str, &IsInstanceEnd)) != NULL) {
2337 DumpNode = NULL;
2338 for (Index = 0; DevPathFromTextTable[Index].Function; Index++) {
2339 ParamStr = GetParamByNodeName (DeviceNodeStr, DevPathFromTextTable[Index].DevicePathNodeText);
2340 if (ParamStr != NULL) {
2341 DumpNode = DevPathFromTextTable[Index].Function;
2342 break;
2343 }
2344 }
2345
2346 if (DumpNode == NULL) {
2347 //
2348 // A file path
2349 //
2350 DumpNode = DevPathFromTextFilePath;
2351 DeviceNode = DumpNode (DeviceNodeStr);
2352 } else {
2353 DeviceNode = DumpNode (ParamStr);
2354 FreePool (ParamStr);
2355 }
2356
2357 NewDevicePath = AppendDeviceNodeProtocolInterface (DevicePath, DeviceNode);
2358 FreePool (DevicePath);
2359 FreePool (DeviceNode);
2360 DevicePath = NewDevicePath;
2361
2362 if (IsInstanceEnd) {
2363 DeviceNode = (EFI_DEVICE_PATH_PROTOCOL *) AllocatePool (END_DEVICE_PATH_LENGTH);
2364 SetDevicePathInstanceEndNode (DeviceNode);
2365
2366 NewDevicePath = AppendDeviceNodeProtocolInterface (DevicePath, DeviceNode);
2367 FreePool (DevicePath);
2368 FreePool (DeviceNode);
2369 DevicePath = NewDevicePath;
2370 }
2371 }
2372
2373 FreePool (DevicePathStr);
2374 return DevicePath;
2375 }
EFI Development Kit II mirror for PVE