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