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