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