]> 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: Fix byte orders when handling 8-byte array
[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
46cced28 4Copyright (c) 2017 - 2018, Intel Corporation. All rights reserved.<BR>\r
7dbc50bd
YZ		 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
27db236a 2390 UINT64 Lun;\r
7dbc50bd
YZ		 2391\r
2392 NameStr = GetNextParamStr (&TextDeviceNode);\r
2393 PortalGroupStr = GetNextParamStr (&TextDeviceNode);\r
2394 LunStr = GetNextParamStr (&TextDeviceNode);\r
2395 HeaderDigestStr = GetNextParamStr (&TextDeviceNode);\r
2396 DataDigestStr = GetNextParamStr (&TextDeviceNode);\r
2397 AuthenticationStr = GetNextParamStr (&TextDeviceNode);\r
2398 ProtocolStr = GetNextParamStr (&TextDeviceNode);\r
2399 ISCSIDevPath = (ISCSI_DEVICE_PATH_WITH_NAME *) CreateDeviceNode (\r
2400 MESSAGING_DEVICE_PATH,\r
2401 MSG_ISCSI_DP,\r
2402 (UINT16) (sizeof (ISCSI_DEVICE_PATH_WITH_NAME) + StrLen (NameStr))\r
2403 );\r
2404\r
2405 AsciiStr = ISCSIDevPath->TargetName;\r
2406 StrToAscii (NameStr, &AsciiStr);\r
2407\r
2408 ISCSIDevPath->TargetPortalGroupTag = (UINT16) Strtoi (PortalGroupStr);\r
27db236a
YZ		 2409 Strtoi64 (LunStr, &Lun);\r
2410 WriteUnaligned64 ((UINT64 *) &ISCSIDevPath->Lun, SwapBytes64 (Lun));\r
7dbc50bd
YZ		 2411\r
2412 Options = 0x0000;\r
2413 if (StrCmp (HeaderDigestStr, L"CRC32C") == 0) {\r
2414 Options |= 0x0002;\r
2415 }\r
2416\r
2417 if (StrCmp (DataDigestStr, L"CRC32C") == 0) {\r
2418 Options |= 0x0008;\r
2419 }\r
2420\r
2421 if (StrCmp (AuthenticationStr, L"None") == 0) {\r
2422 Options |= 0x0800;\r
2423 }\r
2424\r
2425 if (StrCmp (AuthenticationStr, L"CHAP_UNI") == 0) {\r
2426 Options |= 0x1000;\r
2427 }\r
2428\r
2429 ISCSIDevPath->LoginOption = (UINT16) Options;\r
2430\r
c1d6749b 2431 if (IS_NULL (*ProtocolStr) || (StrCmp (ProtocolStr, L"TCP") == 0)) {\r
7dbc50bd
YZ		 2432 ISCSIDevPath->NetworkProtocol = 0;\r
2433 } else {\r
2434 //\r
2435 // Undefined and reserved.\r
2436 //\r
2437 ISCSIDevPath->NetworkProtocol = 1;\r
2438 }\r
2439\r
2440 return (EFI_DEVICE_PATH_PROTOCOL *) ISCSIDevPath;\r
2441}\r
2442\r
2443/**\r
2444 Converts a text device path node to VLAN device path structure.\r
2445\r
2446 @param TextDeviceNode The input Text device path node.\r
2447\r
2448 @return A pointer to the newly-created VLAN device path structure.\r
2449\r
2450**/\r
2451EFI_DEVICE_PATH_PROTOCOL *\r
2452DevPathFromTextVlan (\r
2453 CHAR16 *TextDeviceNode\r
2454 )\r
2455{\r
2456 CHAR16 *VlanStr;\r
2457 VLAN_DEVICE_PATH *Vlan;\r
2458\r
2459 VlanStr = GetNextParamStr (&TextDeviceNode);\r
2460 Vlan = (VLAN_DEVICE_PATH *) CreateDeviceNode (\r
2461 MESSAGING_DEVICE_PATH,\r
2462 MSG_VLAN_DP,\r
2463 (UINT16) sizeof (VLAN_DEVICE_PATH)\r
2464 );\r
2465\r
2466 Vlan->VlanId = (UINT16) Strtoi (VlanStr);\r
2467\r
2468 return (EFI_DEVICE_PATH_PROTOCOL *) Vlan;\r
2469}\r
2470\r
2471/**\r
2472 Converts a text device path node to Bluetooth device path structure.\r
2473\r
2474 @param TextDeviceNode The input Text device path node.\r
2475\r
2476 @return A pointer to the newly-created Bluetooth device path structure.\r
2477\r
2478**/\r
2479EFI_DEVICE_PATH_PROTOCOL *\r
2480DevPathFromTextBluetooth (\r
2481 CHAR16 *TextDeviceNode\r
2482 )\r
2483{\r
2484 CHAR16 *BluetoothStr;\r
2485 BLUETOOTH_DEVICE_PATH *BluetoothDp;\r
2486\r
2487 BluetoothStr = GetNextParamStr (&TextDeviceNode);\r
2488 BluetoothDp = (BLUETOOTH_DEVICE_PATH *) CreateDeviceNode (\r
2489 MESSAGING_DEVICE_PATH,\r
2490 MSG_BLUETOOTH_DP,\r
2491 (UINT16) sizeof (BLUETOOTH_DEVICE_PATH)\r
2492 );\r
2493 StrHexToBytes (\r
2494 BluetoothStr,\r
2495 sizeof (BLUETOOTH_ADDRESS) * 2,\r
2496 BluetoothDp->BD_ADDR.Address,\r
2497 sizeof (BLUETOOTH_ADDRESS)\r
2498 );\r
2499 return (EFI_DEVICE_PATH_PROTOCOL *) BluetoothDp;\r
2500}\r
2501\r
2502/**\r
2503 Converts a text device path node to Wi-Fi device path structure.\r
2504\r
2505 @param TextDeviceNode The input Text device path node.\r
2506\r
2507 @return A pointer to the newly-created Wi-Fi device path structure.\r
2508\r
2509**/\r
2510EFI_DEVICE_PATH_PROTOCOL *\r
2511DevPathFromTextWiFi (\r
2512 CHAR16 *TextDeviceNode\r
2513 )\r
2514{\r
2515 CHAR16 *SSIdStr;\r
2516 CHAR8 AsciiStr[33];\r
2517 UINTN DataLen;\r
2518 WIFI_DEVICE_PATH *WiFiDp;\r
2519\r
2520 SSIdStr = GetNextParamStr (&TextDeviceNode);\r
2521 WiFiDp = (WIFI_DEVICE_PATH *) CreateDeviceNode (\r
2522 MESSAGING_DEVICE_PATH,\r
2523 MSG_WIFI_DP,\r
2524 (UINT16) sizeof (WIFI_DEVICE_PATH)\r
2525 );\r
2526\r
2527 if (NULL != SSIdStr) {\r
2528 DataLen = StrLen (SSIdStr);\r
2529 if (StrLen (SSIdStr) > 32) {\r
2530 SSIdStr[32] = L'\0';\r
2531 DataLen = 32;\r
2532 }\r
2533\r
2534 UnicodeStrToAsciiStrS (SSIdStr, AsciiStr, sizeof (AsciiStr));\r
2535 memcpy (WiFiDp->SSId, AsciiStr, DataLen);\r
2536 }\r
2537\r
2538 return (EFI_DEVICE_PATH_PROTOCOL *) WiFiDp;\r
2539}\r
2540\r
2541/**\r
2542 Converts a text device path node to URI device path structure.\r
2543\r
2544 @param TextDeviceNode The input Text device path node.\r
2545\r
2546 @return A pointer to the newly-created URI device path structure.\r
2547\r
2548**/\r
2549EFI_DEVICE_PATH_PROTOCOL *\r
2550DevPathFromTextUri (\r
2551 CHAR16 *TextDeviceNode\r
2552 )\r
2553{\r
2554 CHAR16 *UriStr;\r
2555 UINTN UriLength;\r
2556 URI_DEVICE_PATH *Uri;\r
2557\r
2558 UriStr = GetNextParamStr (&TextDeviceNode);\r
2559 UriLength = StrnLenS (UriStr, MAX_UINT16 - sizeof (URI_DEVICE_PATH));\r
2560 Uri = (URI_DEVICE_PATH *) CreateDeviceNode (\r
2561 MESSAGING_DEVICE_PATH,\r
2562 MSG_URI_DP,\r
2563 (UINT16) (sizeof (URI_DEVICE_PATH) + UriLength)\r
2564 );\r
2565\r
2566 while (UriLength-- != 0) {\r
2567 Uri->Uri[UriLength] = (CHAR8) UriStr[UriLength];\r
2568 }\r
2569\r
2570 return (EFI_DEVICE_PATH_PROTOCOL *) Uri;\r
2571}\r
2572\r
2573/**\r
2574 Converts a media text device path node to media device path structure.\r
2575\r
2576 @param TextDeviceNode The input Text device path node.\r
2577\r
2578 @return A pointer to media device path structure.\r
2579\r
2580**/\r
2581EFI_DEVICE_PATH_PROTOCOL *\r
2582DevPathFromTextMediaPath (\r
2583 CHAR16 *TextDeviceNode\r
2584 )\r
2585{\r
2586 return DevPathFromTextGenericPath (MEDIA_DEVICE_PATH, TextDeviceNode);\r
2587}\r
2588\r
2589/**\r
2590 Converts a text device path node to HD device path structure.\r
2591\r
2592 @param TextDeviceNode The input Text device path node.\r
2593\r
2594 @return A pointer to the newly-created HD device path structure.\r
2595\r
2596**/\r
2597EFI_DEVICE_PATH_PROTOCOL *\r
2598DevPathFromTextHD (\r
2599 CHAR16 *TextDeviceNode\r
2600 )\r
2601{\r
2602 CHAR16 *PartitionStr;\r
2603 CHAR16 *TypeStr;\r
2604 CHAR16 *SignatureStr;\r
2605 CHAR16 *StartStr;\r
2606 CHAR16 *SizeStr;\r
2607 UINT32 Signature32;\r
2608 HARDDRIVE_DEVICE_PATH *Hd;\r
2609\r
2610 PartitionStr = GetNextParamStr (&TextDeviceNode);\r
2611 TypeStr = GetNextParamStr (&TextDeviceNode);\r
2612 SignatureStr = GetNextParamStr (&TextDeviceNode);\r
2613 StartStr = GetNextParamStr (&TextDeviceNode);\r
2614 SizeStr = GetNextParamStr (&TextDeviceNode);\r
2615 Hd = (HARDDRIVE_DEVICE_PATH *) CreateDeviceNode (\r
2616 MEDIA_DEVICE_PATH,\r
2617 MEDIA_HARDDRIVE_DP,\r
2618 (UINT16) sizeof (HARDDRIVE_DEVICE_PATH)\r
2619 );\r
2620\r
2621 Hd->PartitionNumber = (UINT32) Strtoi (PartitionStr);\r
2622\r
2623 ZeroMem (Hd->Signature, 16);\r
2624 Hd->MBRType = (UINT8) 0;\r
2625\r
2626 if (StrCmp (TypeStr, L"MBR") == 0) {\r
2627 Hd->SignatureType = SIGNATURE_TYPE_MBR;\r
2628 Hd->MBRType = 0x01;\r
2629\r
2630 Signature32 = (UINT32) Strtoi (SignatureStr);\r
2631 memcpy (Hd->Signature, &Signature32, sizeof (UINT32));\r
2632 } else if (StrCmp (TypeStr, L"GPT") == 0) {\r
2633 Hd->SignatureType = SIGNATURE_TYPE_GUID;\r
2634 Hd->MBRType = 0x02;\r
2635\r
2636 StrToGuid (SignatureStr, (EFI_GUID *) Hd->Signature);\r
2637 } else {\r
2638 Hd->SignatureType = (UINT8) Strtoi (TypeStr);\r
2639 }\r
2640\r
2641 Strtoi64 (StartStr, &Hd->PartitionStart);\r
2642 Strtoi64 (SizeStr, &Hd->PartitionSize);\r
2643\r
2644 return (EFI_DEVICE_PATH_PROTOCOL *) Hd;\r
2645}\r
2646\r
2647/**\r
2648 Converts a text device path node to CDROM device path structure.\r
2649\r
2650 @param TextDeviceNode The input Text device path node.\r
2651\r
2652 @return A pointer to the newly-created CDROM device path structure.\r
2653\r
2654**/\r
2655EFI_DEVICE_PATH_PROTOCOL *\r
2656DevPathFromTextCDROM (\r
2657 CHAR16 *TextDeviceNode\r
2658 )\r
2659{\r
2660 CHAR16 *EntryStr;\r
2661 CHAR16 *StartStr;\r
2662 CHAR16 *SizeStr;\r
2663 CDROM_DEVICE_PATH *CDROMDevPath;\r
2664\r
2665 EntryStr = GetNextParamStr (&TextDeviceNode);\r
2666 StartStr = GetNextParamStr (&TextDeviceNode);\r
2667 SizeStr = GetNextParamStr (&TextDeviceNode);\r
2668 CDROMDevPath = (CDROM_DEVICE_PATH *) CreateDeviceNode (\r
2669 MEDIA_DEVICE_PATH,\r
2670 MEDIA_CDROM_DP,\r
2671 (UINT16) sizeof (CDROM_DEVICE_PATH)\r
2672 );\r
2673\r
2674 CDROMDevPath->BootEntry = (UINT32) Strtoi (EntryStr);\r
2675 Strtoi64 (StartStr, &CDROMDevPath->PartitionStart);\r
2676 Strtoi64 (SizeStr, &CDROMDevPath->PartitionSize);\r
2677\r
2678 return (EFI_DEVICE_PATH_PROTOCOL *) CDROMDevPath;\r
2679}\r
2680\r
2681/**\r
2682 Converts a text device path node to Vendor-defined media device path structure.\r
2683\r
2684 @param TextDeviceNode The input Text device path node.\r
2685\r
2686 @return A pointer to the newly-created Vendor-defined media device path structure.\r
2687\r
2688**/\r
2689EFI_DEVICE_PATH_PROTOCOL *\r
2690DevPathFromTextVenMedia (\r
2691 CHAR16 *TextDeviceNode\r
2692 )\r
2693{\r
2694 return ConvertFromTextVendor (\r
2695 TextDeviceNode,\r
2696 MEDIA_DEVICE_PATH,\r
2697 MEDIA_VENDOR_DP\r
2698 );\r
2699}\r
2700\r
2701/**\r
2702 Converts a text device path node to File device path structure.\r
2703\r
2704 @param TextDeviceNode The input Text device path node.\r
2705\r
2706 @return A pointer to the newly-created File device path structure.\r
2707\r
2708**/\r
2709EFI_DEVICE_PATH_PROTOCOL *\r
2710DevPathFromTextFilePath (\r
2711 CHAR16 *TextDeviceNode\r
2712 )\r
2713{\r
2714 FILEPATH_DEVICE_PATH *File;\r
2715\r
2716 File = (FILEPATH_DEVICE_PATH *) CreateDeviceNode (\r
2717 MEDIA_DEVICE_PATH,\r
2718 MEDIA_FILEPATH_DP,\r
2719 (UINT16) (sizeof (FILEPATH_DEVICE_PATH) + StrLen (TextDeviceNode) * 2)\r
2720 );\r
2721\r
2722 StrCpyS (File->PathName, StrLen (TextDeviceNode) + 1, TextDeviceNode);\r
2723\r
2724 return (EFI_DEVICE_PATH_PROTOCOL *) File;\r
2725}\r
2726\r
2727/**\r
2728 Converts a text device path node to Media protocol device path structure.\r
2729\r
2730 @param TextDeviceNode The input Text device path node.\r
2731\r
2732 @return A pointer to the newly-created Media protocol device path structure.\r
2733\r
2734**/\r
2735EFI_DEVICE_PATH_PROTOCOL *\r
2736DevPathFromTextMedia (\r
2737 CHAR16 *TextDeviceNode\r
2738 )\r
2739{\r
2740 CHAR16 *GuidStr;\r
2741 MEDIA_PROTOCOL_DEVICE_PATH *Media;\r
2742\r
2743 GuidStr = GetNextParamStr (&TextDeviceNode);\r
2744 Media = (MEDIA_PROTOCOL_DEVICE_PATH *) CreateDeviceNode (\r
2745 MEDIA_DEVICE_PATH,\r
2746 MEDIA_PROTOCOL_DP,\r
2747 (UINT16) sizeof (MEDIA_PROTOCOL_DEVICE_PATH)\r
2748 );\r
2749\r
2750 StrToGuid (GuidStr, &Media->Protocol);\r
2751\r
2752 return (EFI_DEVICE_PATH_PROTOCOL *) Media;\r
2753}\r
2754\r
2755/**\r
2756 Converts a text device path node to firmware volume device path structure.\r
2757\r
2758 @param TextDeviceNode The input Text device path node.\r
2759\r
2760 @return A pointer to the newly-created firmware volume device path structure.\r
2761\r
2762**/\r
2763EFI_DEVICE_PATH_PROTOCOL *\r
2764DevPathFromTextFv (\r
2765 CHAR16 *TextDeviceNode\r
2766 )\r
2767{\r
2768 CHAR16 *GuidStr;\r
2769 MEDIA_FW_VOL_DEVICE_PATH *Fv;\r
2770\r
2771 GuidStr = GetNextParamStr (&TextDeviceNode);\r
2772 Fv = (MEDIA_FW_VOL_DEVICE_PATH *) CreateDeviceNode (\r
2773 MEDIA_DEVICE_PATH,\r
2774 MEDIA_PIWG_FW_VOL_DP,\r
2775 (UINT16) sizeof (MEDIA_FW_VOL_DEVICE_PATH)\r
2776 );\r
2777\r
2778 StrToGuid (GuidStr, &Fv->FvName);\r
2779\r
2780 return (EFI_DEVICE_PATH_PROTOCOL *) Fv;\r
2781}\r
2782\r
2783/**\r
2784 Converts a text device path node to firmware file device path structure.\r
2785\r
2786 @param TextDeviceNode The input Text device path node.\r
2787\r
2788 @return A pointer to the newly-created firmware file device path structure.\r
2789\r
2790**/\r
2791EFI_DEVICE_PATH_PROTOCOL *\r
2792DevPathFromTextFvFile (\r
2793 CHAR16 *TextDeviceNode\r
2794 )\r
2795{\r
2796 CHAR16 *GuidStr;\r
2797 MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *FvFile;\r
2798\r
2799 GuidStr = GetNextParamStr (&TextDeviceNode);\r
2800 FvFile = (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) CreateDeviceNode (\r
2801 MEDIA_DEVICE_PATH,\r
2802 MEDIA_PIWG_FW_FILE_DP,\r
2803 (UINT16) sizeof (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH)\r
2804 );\r
2805\r
2806 StrToGuid (GuidStr, &FvFile->FvFileName);\r
2807\r
2808 return (EFI_DEVICE_PATH_PROTOCOL *) FvFile;\r
2809}\r
2810\r
2811/**\r
2812 Converts a text device path node to text relative offset device path structure.\r
2813\r
2814 @param TextDeviceNode The input Text device path node.\r
2815\r
2816 @return A pointer to the newly-created Text device path structure.\r
2817\r
2818**/\r
2819EFI_DEVICE_PATH_PROTOCOL *\r
2820DevPathFromTextRelativeOffsetRange (\r
2821 CHAR16 *TextDeviceNode\r
2822 )\r
2823{\r
2824 CHAR16 *StartingOffsetStr;\r
2825 CHAR16 *EndingOffsetStr;\r
2826 MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH *Offset;\r
2827\r
2828 StartingOffsetStr = GetNextParamStr (&TextDeviceNode);\r
2829 EndingOffsetStr = GetNextParamStr (&TextDeviceNode);\r
2830 Offset = (MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH *) CreateDeviceNode (\r
2831 MEDIA_DEVICE_PATH,\r
2832 MEDIA_RELATIVE_OFFSET_RANGE_DP,\r
2833 (UINT16) sizeof (MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH)\r
2834 );\r
2835\r
2836 Strtoi64 (StartingOffsetStr, &Offset->StartingOffset);\r
2837 Strtoi64 (EndingOffsetStr, &Offset->EndingOffset);\r
2838\r
2839 return (EFI_DEVICE_PATH_PROTOCOL *) Offset;\r
2840}\r
2841\r
2842/**\r
2843 Converts a text device path node to text ram disk device path structure.\r
2844\r
2845 @param TextDeviceNode The input Text device path node.\r
2846\r
2847 @return A pointer to the newly-created Text device path structure.\r
2848\r
2849**/\r
2850EFI_DEVICE_PATH_PROTOCOL *\r
2851DevPathFromTextRamDisk (\r
2852 CHAR16 *TextDeviceNode\r
2853 )\r
2854{\r
2855 CHAR16 *StartingAddrStr;\r
2856 CHAR16 *EndingAddrStr;\r
2857 CHAR16 *TypeGuidStr;\r
2858 CHAR16 *InstanceStr;\r
2859 MEDIA_RAM_DISK_DEVICE_PATH *RamDisk;\r
2860 UINT64 StartingAddr;\r
2861 UINT64 EndingAddr;\r
2862\r
2863 StartingAddrStr = GetNextParamStr (&TextDeviceNode);\r
2864 EndingAddrStr = GetNextParamStr (&TextDeviceNode);\r
2865 InstanceStr = GetNextParamStr (&TextDeviceNode);\r
2866 TypeGuidStr = GetNextParamStr (&TextDeviceNode);\r
2867 RamDisk = (MEDIA_RAM_DISK_DEVICE_PATH *) CreateDeviceNode (\r
2868 MEDIA_DEVICE_PATH,\r
2869 MEDIA_RAM_DISK_DP,\r
2870 (UINT16) sizeof (MEDIA_RAM_DISK_DEVICE_PATH)\r
2871 );\r
2872\r
2873 Strtoi64 (StartingAddrStr, &StartingAddr);\r
2874 WriteUnaligned64 ((UINT64 *) &(RamDisk->StartingAddr[0]), StartingAddr);\r
2875 Strtoi64 (EndingAddrStr, &EndingAddr);\r
2876 WriteUnaligned64 ((UINT64 *) &(RamDisk->EndingAddr[0]), EndingAddr);\r
2877 RamDisk->Instance = (UINT16) Strtoi (InstanceStr);\r
2878 StrToGuid (TypeGuidStr, &RamDisk->TypeGuid);\r
2879\r
2880 return (EFI_DEVICE_PATH_PROTOCOL *) RamDisk;\r
2881}\r
2882\r
2883/**\r
2884 Converts a text device path node to text virtual disk device path structure.\r
2885\r
2886 @param TextDeviceNode The input Text device path node.\r
2887\r
2888 @return A pointer to the newly-created Text device path structure.\r
2889\r
2890**/\r
2891EFI_DEVICE_PATH_PROTOCOL *\r
2892DevPathFromTextVirtualDisk (\r
2893 CHAR16 *TextDeviceNode\r
2894 )\r
2895{\r
2896 CHAR16 *StartingAddrStr;\r
2897 CHAR16 *EndingAddrStr;\r
2898 CHAR16 *InstanceStr;\r
2899 MEDIA_RAM_DISK_DEVICE_PATH *RamDisk;\r
2900 UINT64 StartingAddr;\r
2901 UINT64 EndingAddr;\r
2902\r
2903 StartingAddrStr = GetNextParamStr (&TextDeviceNode);\r
2904 EndingAddrStr = GetNextParamStr (&TextDeviceNode);\r
2905 InstanceStr = GetNextParamStr (&TextDeviceNode);\r
2906\r
2907 RamDisk = (MEDIA_RAM_DISK_DEVICE_PATH *) CreateDeviceNode (\r
2908 MEDIA_DEVICE_PATH,\r
2909 MEDIA_RAM_DISK_DP,\r
2910 (UINT16) sizeof (MEDIA_RAM_DISK_DEVICE_PATH)\r
2911 );\r
2912\r
2913 Strtoi64 (StartingAddrStr, &StartingAddr);\r
2914 WriteUnaligned64 ((UINT64 *) &(RamDisk->StartingAddr[0]), StartingAddr);\r
2915 Strtoi64 (EndingAddrStr, &EndingAddr);\r
2916 WriteUnaligned64 ((UINT64 *) &(RamDisk->EndingAddr[0]), EndingAddr);\r
2917 RamDisk->Instance = (UINT16) Strtoi (InstanceStr);\r
2918 CopyGuid (&RamDisk->TypeGuid, &gEfiVirtualDiskGuid);\r
2919\r
2920 return (EFI_DEVICE_PATH_PROTOCOL *) RamDisk;\r
2921}\r
2922\r
2923/**\r
2924 Converts a text device path node to text virtual cd device path structure.\r
2925\r
2926 @param TextDeviceNode The input Text device path node.\r
2927\r
2928 @return A pointer to the newly-created Text device path structure.\r
2929\r
2930**/\r
2931EFI_DEVICE_PATH_PROTOCOL *\r
2932DevPathFromTextVirtualCd (\r
2933 CHAR16 *TextDeviceNode\r
2934 )\r
2935{\r
2936 CHAR16 *StartingAddrStr;\r
2937 CHAR16 *EndingAddrStr;\r
2938 CHAR16 *InstanceStr;\r
2939 MEDIA_RAM_DISK_DEVICE_PATH *RamDisk;\r
2940 UINT64 StartingAddr;\r
2941 UINT64 EndingAddr;\r
2942\r
2943 StartingAddrStr = GetNextParamStr (&TextDeviceNode);\r
2944 EndingAddrStr = GetNextParamStr (&TextDeviceNode);\r
2945 InstanceStr = GetNextParamStr (&TextDeviceNode);\r
2946\r
2947 RamDisk = (MEDIA_RAM_DISK_DEVICE_PATH *) CreateDeviceNode (\r
2948 MEDIA_DEVICE_PATH,\r
2949 MEDIA_RAM_DISK_DP,\r
2950 (UINT16) sizeof (MEDIA_RAM_DISK_DEVICE_PATH)\r
2951 );\r
2952\r
2953 Strtoi64 (StartingAddrStr, &StartingAddr);\r
2954 WriteUnaligned64 ((UINT64 *) &(RamDisk->StartingAddr[0]), StartingAddr);\r
2955 Strtoi64 (EndingAddrStr, &EndingAddr);\r
2956 WriteUnaligned64 ((UINT64 *) &(RamDisk->EndingAddr[0]), EndingAddr);\r
2957 RamDisk->Instance = (UINT16) Strtoi (InstanceStr);\r
2958 CopyGuid (&RamDisk->TypeGuid, &gEfiVirtualCdGuid);\r
2959\r
2960 return (EFI_DEVICE_PATH_PROTOCOL *) RamDisk;\r
2961}\r
2962\r
2963/**\r
2964 Converts a text device path node to text persistent virtual disk device path structure.\r
2965\r
2966 @param TextDeviceNode The input Text device path node.\r
2967\r
2968 @return A pointer to the newly-created Text device path structure.\r
2969\r
2970**/\r
2971EFI_DEVICE_PATH_PROTOCOL *\r
2972DevPathFromTextPersistentVirtualDisk (\r
2973 CHAR16 *TextDeviceNode\r
2974 )\r
2975{\r
2976 CHAR16 *StartingAddrStr;\r
2977 CHAR16 *EndingAddrStr;\r
2978 CHAR16 *InstanceStr;\r
2979 MEDIA_RAM_DISK_DEVICE_PATH *RamDisk;\r
2980 UINT64 StartingAddr;\r
2981 UINT64 EndingAddr;\r
2982\r
2983 StartingAddrStr = GetNextParamStr (&TextDeviceNode);\r
2984 EndingAddrStr = GetNextParamStr (&TextDeviceNode);\r
2985 InstanceStr = GetNextParamStr (&TextDeviceNode);\r
2986\r
2987 RamDisk = (MEDIA_RAM_DISK_DEVICE_PATH *) CreateDeviceNode (\r
2988 MEDIA_DEVICE_PATH,\r
2989 MEDIA_RAM_DISK_DP,\r
2990 (UINT16) sizeof (MEDIA_RAM_DISK_DEVICE_PATH)\r
2991 );\r
2992\r
2993 Strtoi64 (StartingAddrStr, &StartingAddr);\r
2994 WriteUnaligned64 ((UINT64 *) &(RamDisk->StartingAddr[0]), StartingAddr);\r
2995 Strtoi64 (EndingAddrStr, &EndingAddr);\r
2996 WriteUnaligned64 ((UINT64 *) &(RamDisk->EndingAddr[0]), EndingAddr);\r
2997 RamDisk->Instance = (UINT16) Strtoi (InstanceStr);\r
2998 CopyGuid (&RamDisk->TypeGuid, &gEfiPersistentVirtualDiskGuid);\r
2999\r
3000 return (EFI_DEVICE_PATH_PROTOCOL *) RamDisk;\r
3001}\r
3002\r
3003/**\r
3004 Converts a text device path node to text persistent virtual cd device path structure.\r
3005\r
3006 @param TextDeviceNode The input Text device path node.\r
3007\r
3008 @return A pointer to the newly-created Text device path structure.\r
3009\r
3010**/\r
3011EFI_DEVICE_PATH_PROTOCOL *\r
3012DevPathFromTextPersistentVirtualCd (\r
3013 CHAR16 *TextDeviceNode\r
3014 )\r
3015{\r
3016 CHAR16 *StartingAddrStr;\r
3017 CHAR16 *EndingAddrStr;\r
3018 CHAR16 *InstanceStr;\r
3019 MEDIA_RAM_DISK_DEVICE_PATH *RamDisk;\r
3020 UINT64 StartingAddr;\r
3021 UINT64 EndingAddr;\r
3022\r
3023 StartingAddrStr = GetNextParamStr (&TextDeviceNode);\r
3024 EndingAddrStr = GetNextParamStr (&TextDeviceNode);\r
3025 InstanceStr = GetNextParamStr (&TextDeviceNode);\r
3026\r
3027 RamDisk = (MEDIA_RAM_DISK_DEVICE_PATH *) CreateDeviceNode (\r
3028 MEDIA_DEVICE_PATH,\r
3029 MEDIA_RAM_DISK_DP,\r
3030 (UINT16) sizeof (MEDIA_RAM_DISK_DEVICE_PATH)\r
3031 );\r
3032\r
3033 Strtoi64 (StartingAddrStr, &StartingAddr);\r
3034 WriteUnaligned64 ((UINT64 *) &(RamDisk->StartingAddr[0]), StartingAddr);\r
3035 Strtoi64 (EndingAddrStr, &EndingAddr);\r
3036 WriteUnaligned64 ((UINT64 *) &(RamDisk->EndingAddr[0]), EndingAddr);\r
3037 RamDisk->Instance = (UINT16) Strtoi (InstanceStr);\r
3038 CopyGuid (&RamDisk->TypeGuid, &gEfiPersistentVirtualCdGuid);\r
3039\r
3040 return (EFI_DEVICE_PATH_PROTOCOL *) RamDisk;\r
3041}\r
3042\r
3043/**\r
3044 Converts a BBS text device path node to BBS device path structure.\r
3045\r
3046 @param TextDeviceNode The input Text device path node.\r
3047\r
3048 @return A pointer to BBS device path structure.\r
3049\r
3050**/\r
3051EFI_DEVICE_PATH_PROTOCOL *\r
3052DevPathFromTextBbsPath (\r
3053 CHAR16 *TextDeviceNode\r
3054 )\r
3055{\r
3056 return DevPathFromTextGenericPath (BBS_DEVICE_PATH, TextDeviceNode);\r
3057}\r
3058\r
3059/**\r
3060 Converts a text device path node to BIOS Boot Specification device path structure.\r
3061\r
3062 @param TextDeviceNode The input Text device path node.\r
3063\r
3064 @return A pointer to the newly-created BIOS Boot Specification device path structure.\r
3065\r
3066**/\r
3067EFI_DEVICE_PATH_PROTOCOL *\r
3068DevPathFromTextBBS (\r
3069 CHAR16 *TextDeviceNode\r
3070 )\r
3071{\r
3072 CHAR16 *TypeStr;\r
3073 CHAR16 *IdStr;\r
3074 CHAR16 *FlagsStr;\r
3075 CHAR8 *AsciiStr;\r
3076 BBS_BBS_DEVICE_PATH *Bbs;\r
3077\r
3078 TypeStr = GetNextParamStr (&TextDeviceNode);\r
3079 IdStr = GetNextParamStr (&TextDeviceNode);\r
3080 FlagsStr = GetNextParamStr (&TextDeviceNode);\r
3081 Bbs = (BBS_BBS_DEVICE_PATH *) CreateDeviceNode (\r
3082 BBS_DEVICE_PATH,\r
3083 BBS_BBS_DP,\r
3084 (UINT16) (sizeof (BBS_BBS_DEVICE_PATH) + StrLen (IdStr))\r
3085 );\r
3086\r
3087 if (StrCmp (TypeStr, L"Floppy") == 0) {\r
3088 Bbs->DeviceType = BBS_TYPE_FLOPPY;\r
3089 } else if (StrCmp (TypeStr, L"HD") == 0) {\r
3090 Bbs->DeviceType = BBS_TYPE_HARDDRIVE;\r
3091 } else if (StrCmp (TypeStr, L"CDROM") == 0) {\r
3092 Bbs->DeviceType = BBS_TYPE_CDROM;\r
3093 } else if (StrCmp (TypeStr, L"PCMCIA") == 0) {\r
3094 Bbs->DeviceType = BBS_TYPE_PCMCIA;\r
3095 } else if (StrCmp (TypeStr, L"USB") == 0) {\r
3096 Bbs->DeviceType = BBS_TYPE_USB;\r
3097 } else if (StrCmp (TypeStr, L"Network") == 0) {\r
3098 Bbs->DeviceType = BBS_TYPE_EMBEDDED_NETWORK;\r
3099 } else {\r
3100 Bbs->DeviceType = (UINT16) Strtoi (TypeStr);\r
3101 }\r
3102\r
3103 AsciiStr = Bbs->String;\r
3104 StrToAscii (IdStr, &AsciiStr);\r
3105\r
3106 Bbs->StatusFlag = (UINT16) Strtoi (FlagsStr);\r
3107\r
3108 return (EFI_DEVICE_PATH_PROTOCOL *) Bbs;\r
3109}\r
3110\r
3111/**\r
3112 Converts a text device path node to SATA device path structure.\r
3113\r
3114 @param TextDeviceNode The input Text device path node.\r
3115\r
3116 @return A pointer to the newly-created SATA device path structure.\r
3117\r
3118**/\r
3119EFI_DEVICE_PATH_PROTOCOL *\r
3120DevPathFromTextSata (\r
3121 CHAR16 *TextDeviceNode\r
3122 )\r
3123{\r
3124 SATA_DEVICE_PATH *Sata;\r
3125 CHAR16 *Param1;\r
3126 CHAR16 *Param2;\r
3127 CHAR16 *Param3;\r
3128\r
3129 Param1 = GetNextParamStr (&TextDeviceNode);\r
3130 Param2 = GetNextParamStr (&TextDeviceNode);\r
3131 Param3 = GetNextParamStr (&TextDeviceNode);\r
3132\r
3133 Sata = (SATA_DEVICE_PATH *) CreateDeviceNode (\r
3134 MESSAGING_DEVICE_PATH,\r
3135 MSG_SATA_DP,\r
3136 (UINT16) sizeof (SATA_DEVICE_PATH)\r
3137 );\r
3138 Sata->HBAPortNumber = (UINT16) Strtoi (Param1);\r
3139 Sata->PortMultiplierPortNumber = (UINT16) Strtoi (Param2);\r
3140 Sata->Lun = (UINT16) Strtoi (Param3);\r
3141\r
3142 return (EFI_DEVICE_PATH_PROTOCOL *) Sata;\r
3143}\r
3144\r
3145DEVICE_PATH_FROM_TEXT_TABLE mUefiDevicePathLibDevPathFromTextTable[] = {\r
3146 {L"Path", DevPathFromTextPath },\r
3147\r
3148 {L"HardwarePath", DevPathFromTextHardwarePath },\r
3149 {L"Pci", DevPathFromTextPci },\r
3150 {L"PcCard", DevPathFromTextPcCard },\r
3151 {L"MemoryMapped", DevPathFromTextMemoryMapped },\r
3152 {L"VenHw", DevPathFromTextVenHw },\r
3153 {L"Ctrl", DevPathFromTextCtrl },\r
3154 {L"BMC", DevPathFromTextBmc },\r
3155\r
3156 {L"AcpiPath", DevPathFromTextAcpiPath },\r
3157 {L"Acpi", DevPathFromTextAcpi },\r
3158 {L"PciRoot", DevPathFromTextPciRoot },\r
3159 {L"PcieRoot", DevPathFromTextPcieRoot },\r
3160 {L"Floppy", DevPathFromTextFloppy },\r
3161 {L"Keyboard", DevPathFromTextKeyboard },\r
3162 {L"Serial", DevPathFromTextSerial },\r
3163 {L"ParallelPort", DevPathFromTextParallelPort },\r
3164 {L"AcpiEx", DevPathFromTextAcpiEx },\r
3165 {L"AcpiExp", DevPathFromTextAcpiExp },\r
3166 {L"AcpiAdr", DevPathFromTextAcpiAdr },\r
3167\r
3168 {L"Msg", DevPathFromTextMsg },\r
3169 {L"Ata", DevPathFromTextAta },\r
3170 {L"Scsi", DevPathFromTextScsi },\r
3171 {L"Fibre", DevPathFromTextFibre },\r
3172 {L"FibreEx", DevPathFromTextFibreEx },\r
3173 {L"I1394", DevPathFromText1394 },\r
3174 {L"USB", DevPathFromTextUsb },\r
3175 {L"I2O", DevPathFromTextI2O },\r
3176 {L"Infiniband", DevPathFromTextInfiniband },\r
3177 {L"VenMsg", DevPathFromTextVenMsg },\r
3178 {L"VenPcAnsi", DevPathFromTextVenPcAnsi },\r
3179 {L"VenVt100", DevPathFromTextVenVt100 },\r
3180 {L"VenVt100Plus", DevPathFromTextVenVt100Plus },\r
3181 {L"VenUtf8", DevPathFromTextVenUtf8 },\r
3182 {L"UartFlowCtrl", DevPathFromTextUartFlowCtrl },\r
3183 {L"SAS", DevPathFromTextSAS },\r
3184 {L"SasEx", DevPathFromTextSasEx },\r
3185 {L"NVMe", DevPathFromTextNVMe },\r
3186 {L"UFS", DevPathFromTextUfs },\r
3187 {L"SD", DevPathFromTextSd },\r
3188 {L"eMMC", DevPathFromTextEmmc },\r
3189 {L"DebugPort", DevPathFromTextDebugPort },\r
3190 {L"MAC", DevPathFromTextMAC },\r
3191 {L"IPv4", DevPathFromTextIPv4 },\r
3192 {L"IPv6", DevPathFromTextIPv6 },\r
3193 {L"Uart", DevPathFromTextUart },\r
3194 {L"UsbClass", DevPathFromTextUsbClass },\r
3195 {L"UsbAudio", DevPathFromTextUsbAudio },\r
3196 {L"UsbCDCControl", DevPathFromTextUsbCDCControl },\r
3197 {L"UsbHID", DevPathFromTextUsbHID },\r
3198 {L"UsbImage", DevPathFromTextUsbImage },\r
3199 {L"UsbPrinter", DevPathFromTextUsbPrinter },\r
3200 {L"UsbMassStorage", DevPathFromTextUsbMassStorage },\r
3201 {L"UsbHub", DevPathFromTextUsbHub },\r
3202 {L"UsbCDCData", DevPathFromTextUsbCDCData },\r
3203 {L"UsbSmartCard", DevPathFromTextUsbSmartCard },\r
3204 {L"UsbVideo", DevPathFromTextUsbVideo },\r
3205 {L"UsbDiagnostic", DevPathFromTextUsbDiagnostic },\r
3206 {L"UsbWireless", DevPathFromTextUsbWireless },\r
3207 {L"UsbDeviceFirmwareUpdate", DevPathFromTextUsbDeviceFirmwareUpdate },\r
3208 {L"UsbIrdaBridge", DevPathFromTextUsbIrdaBridge },\r
3209 {L"UsbTestAndMeasurement", DevPathFromTextUsbTestAndMeasurement },\r
3210 {L"UsbWwid", DevPathFromTextUsbWwid },\r
3211 {L"Unit", DevPathFromTextUnit },\r
3212 {L"iSCSI", DevPathFromTextiSCSI },\r
3213 {L"Vlan", DevPathFromTextVlan },\r
3214 {L"Uri", DevPathFromTextUri },\r
3215 {L"Bluetooth", DevPathFromTextBluetooth },\r
3216 {L"Wi-Fi", DevPathFromTextWiFi },\r
3217 {L"MediaPath", DevPathFromTextMediaPath },\r
3218 {L"HD", DevPathFromTextHD },\r
3219 {L"CDROM", DevPathFromTextCDROM },\r
3220 {L"VenMedia", DevPathFromTextVenMedia },\r
3221 {L"Media", DevPathFromTextMedia },\r
3222 {L"Fv", DevPathFromTextFv },\r
3223 {L"FvFile", DevPathFromTextFvFile },\r
3224 {L"Offset", DevPathFromTextRelativeOffsetRange },\r
3225 {L"RamDisk", DevPathFromTextRamDisk },\r
3226 {L"VirtualDisk", DevPathFromTextVirtualDisk },\r
3227 {L"VirtualCD", DevPathFromTextVirtualCd },\r
3228 {L"PersistentVirtualDisk", DevPathFromTextPersistentVirtualDisk },\r
3229 {L"PersistentVirtualCD", DevPathFromTextPersistentVirtualCd },\r
3230\r
3231 {L"BbsPath", DevPathFromTextBbsPath },\r
3232 {L"BBS", DevPathFromTextBBS },\r
3233 {L"Sata", DevPathFromTextSata },\r
3234 {NULL, NULL}\r
3235};\r
3236\r
3237/**\r
3238 Convert text to the binary representation of a device node.\r
3239\r
3240 @param TextDeviceNode TextDeviceNode points to the text representation of a device\r
3241 node. Conversion starts with the first character and continues\r
3242 until the first non-device node character.\r
3243\r
3244 @return A pointer to the EFI device node or NULL if TextDeviceNode is NULL or there was\r
3245 insufficient memory or text unsupported.\r
3246\r
3247**/\r
3248EFI_DEVICE_PATH_PROTOCOL *\r
3249UefiDevicePathLibConvertTextToDeviceNode (\r
3250 CONST CHAR16 *TextDeviceNode\r
3251 )\r
3252{\r
3253 DEVICE_PATH_FROM_TEXT FromText;\r
3254 CHAR16 *ParamStr;\r
3255 EFI_DEVICE_PATH_PROTOCOL *DeviceNode;\r
3256 CHAR16 *DeviceNodeStr;\r
3257 UINTN Index;\r
3258\r
3259 if ((TextDeviceNode == NULL) || (IS_NULL (*TextDeviceNode))) {\r
3260 return NULL;\r
3261 }\r
3262\r
3263 ParamStr = NULL;\r
3264 FromText = NULL;\r
3265 DeviceNodeStr = UefiDevicePathLibStrDuplicate (TextDeviceNode);\r
3266 ASSERT (DeviceNodeStr != NULL);\r
3267\r
3268 for (Index = 0; mUefiDevicePathLibDevPathFromTextTable[Index].Function != NULL; Index++) {\r
3269 ParamStr = GetParamByNodeName (DeviceNodeStr, mUefiDevicePathLibDevPathFromTextTable[Index].DevicePathNodeText);\r
3270 if (ParamStr != NULL) {\r
3271 FromText = mUefiDevicePathLibDevPathFromTextTable[Index].Function;\r
3272 break;\r
3273 }\r
3274 }\r
3275\r
3276 if (FromText == NULL) {\r
3277 //\r
3278 // A file path\r
3279 //\r
3280 FromText = DevPathFromTextFilePath;\r
3281 DeviceNode = FromText (DeviceNodeStr);\r
46cced28
HW		 3282 //\r
3283 // According to above logic, if 'FromText' is NULL in the 'if' statement,\r
3284 // then 'ParamStr' must be NULL as well. No memory allocation has been made\r
3285 // in this case.\r
3286 //\r
3287 // The below check is for addressing a false positive potential memory leak\r
3288 // issue raised from static analysis.\r
3289 //\r
3290 if (ParamStr != NULL) {\r
3291 free (ParamStr);\r
3292 }\r
7dbc50bd
YZ		 3293 } else {\r
3294 DeviceNode = FromText (ParamStr);\r
3295 free (ParamStr);\r
3296 }\r
3297\r
3298 free (DeviceNodeStr);\r
3299\r
3300 return DeviceNode;\r
3301}\r
3302\r
3303/**\r
3304 Convert text to the binary representation of a device path.\r
3305\r
3306\r
3307 @param TextDevicePath TextDevicePath points to the text representation of a device\r
3308 path. Conversion starts with the first character and continues\r
3309 until the first non-device node character.\r
3310\r
3311 @return A pointer to the allocated device path or NULL if TextDeviceNode is NULL or\r
3312 there was insufficient memory.\r
3313\r
3314**/\r
3315EFI_DEVICE_PATH_PROTOCOL *\r
3316UefiDevicePathLibConvertTextToDevicePath (\r
3317 CONST CHAR16 *TextDevicePath\r
3318 )\r
3319{\r
3320 EFI_DEVICE_PATH_PROTOCOL *DeviceNode;\r
3321 EFI_DEVICE_PATH_PROTOCOL *NewDevicePath;\r
3322 CHAR16 *DevicePathStr;\r
3323 CHAR16 *Str;\r
3324 CHAR16 *DeviceNodeStr;\r
3325 BOOLEAN IsInstanceEnd;\r
3326 EFI_DEVICE_PATH_PROTOCOL *DevicePath;\r
3327\r
3328 if ((TextDevicePath == NULL) || (IS_NULL (*TextDevicePath))) {\r
3329 return NULL;\r
3330 }\r
3331\r
3332 DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) AllocatePool (END_DEVICE_PATH_LENGTH);\r
3333 ASSERT (DevicePath != NULL);\r
3334 SetDevicePathEndNode (DevicePath);\r
3335\r
3336 DevicePathStr = UefiDevicePathLibStrDuplicate (TextDevicePath);\r
3337\r
3338 Str = DevicePathStr;\r
3339 while ((DeviceNodeStr = GetNextDeviceNodeStr (&Str, &IsInstanceEnd)) != NULL) {\r
3340 DeviceNode = UefiDevicePathLibConvertTextToDeviceNode (DeviceNodeStr);\r
3341\r
3342 NewDevicePath = AppendDevicePathNode (DevicePath, DeviceNode);\r
3343 free (DevicePath);\r
3344 free (DeviceNode);\r
3345 DevicePath = NewDevicePath;\r
3346\r
3347 if (IsInstanceEnd) {\r
3348 DeviceNode = (EFI_DEVICE_PATH_PROTOCOL *) AllocatePool (END_DEVICE_PATH_LENGTH);\r
3349 ASSERT (DeviceNode != NULL);\r
3350 SetDevicePathEndNode (DeviceNode);\r
3351 DeviceNode->SubType = END_INSTANCE_DEVICE_PATH_SUBTYPE;\r
3352\r
3353 NewDevicePath = AppendDevicePathNode (DevicePath, DeviceNode);\r
3354 free (DevicePath);\r
3355 free (DeviceNode);\r
3356 DevicePath = NewDevicePath;\r
3357 }\r
3358 }\r
3359\r
3360 free (DevicePathStr);\r
3361 return DevicePath;\r
3362}\r
EFI Development Kit II mirror for PVE