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