lib/libefivar/efivar-dp-parse.c

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