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