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