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