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