MdeModulePkg/Universal/DevicePathDxe/DevicePathFromText.c

   1 /*++
   2
   3 Copyright (c) 2006, Intel Corporation
   4 All rights reserved. This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 Module Name:
  13
  14   DevicePathFromText.c
  15
  16 Abstract:
  17
  18   DevicePathFromText protocol as defined in the UEFI 2.0 specification.
  19
  20 --*/
  21
  22 #include "DevicePath.h"
  23
  24 STATIC
  25 CHAR16 *
  26 StrDuplicate (
  27   IN CONST CHAR16  *Src
  28   )
  29 /*++
  30
  31   Routine Description:
  32     Duplicate a string
  33
  34   Arguments:
  35     Src - Source string
  36
  37   Returns:
  38     Duplicated string
  39
  40 --*/
  41 {
  42   UINTN   Length;
  43   CHAR16  *ReturnStr;
  44
  45   Length = StrLen ((CHAR16 *) Src);
  46
  47   ReturnStr = AllocateCopyPool ((Length + 1) * sizeof (CHAR16), (VOID *) Src);
  48
  49   return ReturnStr;
  50 }
  51
  52 STATIC
  53 CHAR16 *
  54 GetParamByNodeName (
  55   IN CHAR16 *Str,
  56   IN CHAR16 *NodeName
  57   )
  58 /*++
  59
  60   Routine Description:
  61     Get parameter in a pair of parentheses follow the given node name.
  62     For example, given the "Pci(0,1)" and NodeName "Pci", it returns "0,1".
  63
  64   Arguments:
  65     Str      - Device Path Text
  66     NodeName - Name of the node
  67
  68   Returns:
  69     Parameter text for the node
  70
  71 --*/
  72 {
  73   CHAR16  *ParamStr;
  74   CHAR16  *StrPointer;
  75   UINTN   NodeNameLength;
  76   UINTN   ParameterLength;
  77
  78   //
  79   // Check whether the node name matchs
  80   //
  81   NodeNameLength = StrLen (NodeName);
  82   if (CompareMem (Str, NodeName, NodeNameLength * sizeof (CHAR16)) != 0) {
  83     return NULL;
  84   }
  85
  86   ParamStr = Str + NodeNameLength;
  87   if (!IS_LEFT_PARENTH (*ParamStr)) {
  88     return NULL;
  89   }
  90
  91   //
  92   // Skip the found '(' and find first occurrence of ')'
  93   //
  94   ParamStr++;
  95   ParameterLength = 0;
  96   StrPointer = ParamStr;
  97   while (!IS_NULL (*StrPointer)) {
  98     if (IS_RIGHT_PARENTH (*StrPointer)) {
  99       break;
 100     }
 101     StrPointer++;
 102     ParameterLength++;
 103   }
 104   if (IS_NULL (*StrPointer)) {
 105     //
 106     // ')' not found
 107     //
 108     return NULL;
 109   }
 110
 111   ParamStr = AllocateCopyPool ((ParameterLength + 1) * sizeof (CHAR16), ParamStr);
 112   if (ParamStr == NULL) {
 113     return NULL;
 114   }
 115   //
 116   // Terminate the parameter string
 117   //
 118   ParamStr[ParameterLength] = L'\0';
 119
 120   return ParamStr;
 121 }
 122
 123 STATIC
 124 CHAR16 *
 125 SplitStr (
 126   IN OUT CHAR16 **List,
 127   IN     CHAR16 Separator
 128   )
 129 /*++
 130
 131   Routine Description:
 132     Get current sub-string from a string list, before return
 133     the list header is moved to next sub-string. The sub-string is separated
 134     by the specified character. For example, the separator is ',', the string
 135     list is "2,0,3", it returns "2", the remain list move to "0,3"
 136
 137   Arguments:
 138     List       - A string list separated by the specified separator
 139     Separator  - The separator character
 140
 141   Returns:
 142     pointer    - The current sub-string
 143
 144 --*/
 145 {
 146   CHAR16  *Str;
 147   CHAR16  *ReturnStr;
 148
 149   Str = *List;
 150   ReturnStr = Str;
 151
 152   if (IS_NULL (*Str)) {
 153     return ReturnStr;
 154   }
 155
 156   //
 157   // Find first occurrence of the separator
 158   //
 159   while (!IS_NULL (*Str)) {
 160     if (*Str == Separator) {
 161       break;
 162     }
 163     Str++;
 164   }
 165
 166   if (*Str == Separator) {
 167     //
 168     // Find a sub-string, terminate it
 169     //
 170     *Str = L'\0';
 171     Str++;
 172   }
 173
 174   //
 175   // Move to next sub-string
 176   //
 177   *List = Str;
 178
 179   return ReturnStr;
 180 }
 181
 182 STATIC
 183 CHAR16 *
 184 GetNextParamStr (
 185   IN OUT CHAR16 **List
 186   )
 187 {
 188   //
 189   // The separator is comma
 190   //
 191   return SplitStr (List, L',');
 192 }
 193
 194 STATIC
 195 CHAR16 *
 196 GetNextDeviceNodeStr (
 197   IN OUT CHAR16   **DevicePath,
 198   OUT    BOOLEAN  *IsInstanceEnd
 199   )
 200 /*++
 201
 202   Routine Description:
 203     Get one device node from entire device path text.
 204
 205   Arguments:
 206     Str           - The entire device path text string
 207     IsInstanceEnd - This node is the end of a device path instance
 208
 209   Returns:
 210     a pointer     - A device node text
 211     NULL          - No more device node available
 212
 213 --*/
 214 {
 215   CHAR16  *Str;
 216   CHAR16  *ReturnStr;
 217   UINTN   ParenthesesStack;
 218
 219   Str = *DevicePath;
 220   if (IS_NULL (*Str)) {
 221     return NULL;
 222   }
 223
 224   //
 225   // Skip the leading '/', '(', ')' and ','
 226   //
 227   while (!IS_NULL (*Str)) {
 228     if (!IS_SLASH (*Str) &&
 229         !IS_COMMA (*Str) &&
 230         !IS_LEFT_PARENTH (*Str) &&
 231         !IS_RIGHT_PARENTH (*Str)) {
 232       break;
 233     }
 234     Str++;
 235   }
 236
 237   ReturnStr = Str;
 238
 239   //
 240   // Scan for the separator of this device node, '/' or ','
 241   //
 242   ParenthesesStack = 0;
 243   while (!IS_NULL (*Str)) {
 244     if ((IS_COMMA (*Str) || IS_SLASH (*Str)) && (ParenthesesStack == 0)) {
 245       break;
 246     }
 247
 248     if (IS_LEFT_PARENTH (*Str)) {
 249       ParenthesesStack++;
 250     } else if (IS_RIGHT_PARENTH (*Str)) {
 251       ParenthesesStack--;
 252     }
 253
 254     Str++;
 255   }
 256
 257   if (ParenthesesStack != 0) {
 258     //
 259     // The '(' doesn't pair with ')', invalid device path text
 260     //
 261     return NULL;
 262   }
 263
 264   if (IS_COMMA (*Str)) {
 265     *IsInstanceEnd = TRUE;
 266     *Str = L'\0';
 267     Str++;
 268   } else {
 269     *IsInstanceEnd = FALSE;
 270     if (!IS_NULL (*Str)) {
 271       *Str = L'\0';
 272       Str++;
 273     }
 274   }
 275
 276   *DevicePath = Str;
 277
 278   return ReturnStr;
 279 }
 280
 281 STATIC
 282 BOOLEAN
 283 IsHexDigit (
 284   OUT UINT8      *Digit,
 285   IN  CHAR16      Char
 286   )
 287 /*++
 288
 289   Routine Description:
 290     Determines if a Unicode character is a hexadecimal digit.
 291     The test is case insensitive.
 292
 293   Arguments:
 294     Digit - Pointer to byte that receives the value of the hex character.
 295     Char  - Unicode character to test.
 296
 297   Returns:
 298     TRUE  - If the character is a hexadecimal digit.
 299     FALSE - Otherwise.
 300
 301 --*/
 302 {
 303   if ((Char >= L'0') && (Char <= L'9')) {
 304     *Digit = (UINT8) (Char - L'0');
 305     return TRUE;
 306   }
 307
 308   if ((Char >= L'A') && (Char <= L'F')) {
 309     *Digit = (UINT8) (Char - L'A' + 0x0A);
 310     return TRUE;
 311   }
 312
 313   if ((Char >= L'a') && (Char <= L'f')) {
 314     *Digit = (UINT8) (Char - L'a' + 0x0A);
 315     return TRUE;
 316   }
 317
 318   return FALSE;
 319 }
 320
 321 STATIC
 322 EFI_STATUS
 323 HexStringToBuf (
 324   IN OUT UINT8                     *Buf,
 325   IN OUT UINTN                     *Len,
 326   IN     CHAR16                    *Str,
 327   OUT    UINTN                     *ConvertedStrLen  OPTIONAL
 328   )
 329 /*++
 330
 331   Routine Description:
 332     Converts Unicode string to binary buffer.
 333     The conversion may be partial.
 334     The first character in the string that is not hex digit stops the conversion.
 335     At a minimum, any blob of data could be represented as a hex string.
 336
 337   Arguments:
 338     Buf    - Pointer to buffer that receives the data.
 339     Len    - Length in bytes of the buffer to hold converted data.
 340                 If routine return with EFI_SUCCESS, containing length of converted data.
 341                 If routine return with EFI_BUFFER_TOO_SMALL, containg length of buffer desired.
 342     Str    - String to be converted from.
 343     ConvertedStrLen - Length of the Hex String consumed.
 344
 345   Returns:
 346     EFI_SUCCESS: Routine Success.
 347     EFI_BUFFER_TOO_SMALL: The buffer is too small to hold converted data.
 348     EFI_
 349
 350 --*/
 351 {
 352   UINTN       HexCnt;
 353   UINTN       Idx;
 354   UINTN       BufferLength;
 355   UINT8       Digit;
 356   UINT8       Byte;
 357
 358   //
 359   // Find out how many hex characters the string has.
 360   //
 361   for (Idx = 0, HexCnt = 0; IsHexDigit (&Digit, Str[Idx]); Idx++, HexCnt++);
 362
 363   if (HexCnt == 0) {
 364     *Len = 0;
 365     return EFI_SUCCESS;
 366   }
 367   //
 368   // Two Unicode characters make up 1 buffer byte. Round up.
 369   //
 370   BufferLength = (HexCnt + 1) / 2;
 371
 372   //
 373   // Test if  buffer is passed enough.
 374   //
 375   if (BufferLength > (*Len)) {
 376     *Len = BufferLength;
 377     return EFI_BUFFER_TOO_SMALL;
 378   }
 379
 380   *Len = BufferLength;
 381
 382   for (Idx = 0; Idx < HexCnt; Idx++) {
 383
 384     IsHexDigit (&Digit, Str[HexCnt - 1 - Idx]);
 385
 386     //
 387     // For odd charaters, write the lower nibble for each buffer byte,
 388     // and for even characters, the upper nibble.
 389     //
 390     if ((Idx & 1) == 0) {
 391       Byte = Digit;
 392     } else {
 393       Byte = Buf[Idx / 2];
 394       Byte &= 0x0F;
 395       Byte = (UINT8) (Byte | Digit << 4);
 396     }
 397
 398     Buf[Idx / 2] = Byte;
 399   }
 400
 401   if (ConvertedStrLen != NULL) {
 402     *ConvertedStrLen = HexCnt;
 403   }
 404
 405   return EFI_SUCCESS;
 406 }
 407
 408 STATIC
 409 CHAR16 *
 410 TrimHexStr (
 411   IN CHAR16   *Str,
 412   OUT BOOLEAN *IsHex
 413   )
 414 /*++
 415
 416   Routine Description:
 417     Skip the leading white space and '0x' or '0X' of a integer string
 418
 419   Arguments:
 420     Str   -  The integer string
 421     IsHex -  1: Hex string,  0: Decimal string
 422
 423   Returns:
 424
 425 --*/
 426 {
 427   *IsHex = FALSE;
 428
 429   //
 430   // skip preceeding white space
 431   //
 432   while (*Str && *Str == ' ') {
 433     Str += 1;
 434   }
 435   //
 436   // skip preceeding zeros
 437   //
 438   while (*Str && *Str == '0') {
 439     Str += 1;
 440   }
 441   //
 442   // skip preceeding character 'x' or 'X'
 443   //
 444   if (*Str && (*Str == 'x' || *Str == 'X')) {
 445     Str += 1;
 446     *IsHex = TRUE;
 447   }
 448
 449   return Str;
 450 }
 451
 452 STATIC
 453 UINTN
 454 Xtoi (
 455   IN CHAR16  *Str
 456   )
 457 /*++
 458
 459 Routine Description:
 460
 461   Convert hex string to uint
 462
 463 Arguments:
 464
 465   Str  -  The string
 466
 467 Returns:
 468
 469 --*/
 470 {
 471   UINTN   Rvalue;
 472   UINTN   Length;
 473
 474   ASSERT (Str != NULL);
 475
 476   //
 477   // convert hex digits
 478   //
 479   Rvalue = 0;
 480   Length = sizeof (UINTN);
 481   HexStringToBuf ((UINT8 *) &Rvalue, &Length, Str, NULL);
 482
 483   return Rvalue;
 484 }
 485
 486 STATIC
 487 VOID
 488 Xtoi64 (
 489   IN CHAR16  *Str,
 490   IN UINT64  *Data
 491   )
 492 /*++
 493
 494 Routine Description:
 495
 496   Convert hex string to 64 bit data.
 497
 498 Arguments:
 499
 500   Str  -  The string
 501
 502 Returns:
 503
 504 --*/
 505 {
 506   UINTN  Length;
 507
 508   *Data  = 0;
 509   Length = sizeof (UINT64);
 510   HexStringToBuf ((UINT8 *) Data, &Length, Str, NULL);
 511 }
 512
 513 STATIC
 514 UINTN
 515 Dtoi (
 516   IN CHAR16  *str
 517   )
 518 /*++
 519
 520 Routine Description:
 521
 522   Convert decimal string to uint
 523
 524 Arguments:
 525
 526   Str  -  The string
 527
 528 Returns:
 529
 530 --*/
 531 {
 532   UINTN   Rvalue;
 533   CHAR16  Char;
 534   UINTN   High;
 535   UINTN   Low;
 536
 537   ASSERT (str != NULL);
 538
 539   High = (UINTN) -1 / 10;
 540   Low  = (UINTN) -1 % 10;
 541   //
 542   // skip preceeding white space
 543   //
 544   while (*str && *str == ' ') {
 545     str += 1;
 546   }
 547   //
 548   // convert digits
 549   //
 550   Rvalue = 0;
 551   Char = *(str++);
 552   while (Char) {
 553     if (Char >= '0' && Char <= '9') {
 554       if ((Rvalue > High || Rvalue == High) && (Char - '0' > (INTN) Low)) {
 555         return (UINTN) -1;
 556       }
 557
 558       Rvalue = (Rvalue * 10) + Char - '0';
 559     } else {
 560       break;
 561     }
 562
 563     Char = *(str++);
 564   }
 565
 566   return Rvalue;
 567 }
 568
 569 STATIC
 570 VOID
 571 Dtoi64 (
 572   IN CHAR16  *str,
 573   OUT UINT64 *Data
 574   )
 575 /*++
 576
 577 Routine Description:
 578
 579   Convert decimal string to uint
 580
 581 Arguments:
 582
 583   Str  -  The string
 584
 585 Returns:
 586
 587 --*/
 588 {
 589   UINT64   Rvalue;
 590   CHAR16   Char;
 591   UINT64   High;
 592   UINT64   Low;
 593
 594   ASSERT (str != NULL);
 595   ASSERT (Data != NULL);
 596
 597   //
 598   // skip preceeding white space
 599   //
 600   while (*str && *str == ' ') {
 601     str += 1;
 602   }
 603   //
 604   // convert digits
 605   //
 606   Rvalue = 0;
 607   Char = *(str++);
 608   while (Char) {
 609     if (Char >= '0' && Char <= '9') {
 610       High = LShiftU64 (Rvalue, 3);
 611       Low = LShiftU64 (Rvalue, 1);
 612       Rvalue = High + Low + Char - '0';
 613     } else {
 614       break;
 615     }
 616
 617     Char = *(str++);
 618   }
 619
 620   *Data = Rvalue;
 621 }
 622
 623 STATIC
 624 UINTN
 625 Strtoi (
 626   IN CHAR16  *Str
 627   )
 628 /*++
 629
 630 Routine Description:
 631
 632   Convert integer string to uint.
 633
 634 Arguments:
 635
 636   Str  -  The integer string. If leading with "0x" or "0X", it's heximal.
 637
 638 Returns:
 639
 640 --*/
 641 {
 642   BOOLEAN IsHex;
 643
 644   Str = TrimHexStr (Str, &IsHex);
 645
 646   if (IsHex) {
 647     return Xtoi (Str);
 648   } else {
 649     return Dtoi (Str);
 650   }
 651 }
 652
 653 STATIC
 654 VOID
 655 Strtoi64 (
 656   IN CHAR16  *Str,
 657   IN UINT64  *Data
 658   )
 659 /*++
 660
 661 Routine Description:
 662
 663   Convert integer string to 64 bit data.
 664
 665 Arguments:
 666
 667   Str  -  The integer string. If leading with "0x" or "0X", it's heximal.
 668
 669 Returns:
 670
 671 --*/
 672 {
 673   BOOLEAN IsHex;
 674
 675   Str = TrimHexStr (Str, &IsHex);
 676
 677   if (IsHex) {
 678     Xtoi64 (Str, Data);
 679   } else {
 680     Dtoi64 (Str, Data);
 681   }
 682 }
 683
 684 STATIC
 685 EFI_STATUS
 686 StrToBuf (
 687   OUT UINT8    *Buf,
 688   IN  UINTN    BufferLength,
 689   IN  CHAR16   *Str
 690   )
 691 {
 692   UINTN       Index;
 693   UINTN       StrLength;
 694   UINT8       Digit;
 695   UINT8       Byte;
 696
 697   //
 698   // Two hex char make up one byte
 699   //
 700   StrLength = BufferLength * sizeof (CHAR16);
 701
 702   for(Index = 0; Index < StrLength; Index++, Str++) {
 703
 704     IsHexDigit (&Digit, *Str);
 705
 706     //
 707     // For odd charaters, write the upper nibble for each buffer byte,
 708     // and for even characters, the lower nibble.
 709     //
 710     if ((Index & 1) == 0) {
 711       Byte = (UINT8) (Digit << 4);
 712     } else {
 713       Byte = Buf[Index / 2];
 714       Byte &= 0xF0;
 715       Byte = (UINT8) (Byte | Digit);
 716     }
 717
 718     Buf[Index / 2] = Byte;
 719   }
 720
 721   return EFI_SUCCESS;
 722 }
 723
 724 STATIC
 725 EFI_STATUS
 726 StrToGuid (
 727   IN  CHAR16   *Str,
 728   OUT EFI_GUID *Guid
 729   )
 730 {
 731   UINTN       BufferLength;
 732   UINTN       ConvertedStrLen;
 733   EFI_STATUS  Status;
 734
 735   BufferLength = sizeof (Guid->Data1);
 736   Status = HexStringToBuf ((UINT8 *) &Guid->Data1, &BufferLength, Str, &ConvertedStrLen);
 737   if (EFI_ERROR (Status)) {
 738     return Status;
 739   }
 740   Str += ConvertedStrLen;
 741   if (IS_HYPHEN (*Str)) {
 742     Str++;
 743   } else {
 744     return EFI_UNSUPPORTED;
 745   }
 746
 747   BufferLength = sizeof (Guid->Data2);
 748   Status = HexStringToBuf ((UINT8 *) &Guid->Data2, &BufferLength, Str, &ConvertedStrLen);
 749   if (EFI_ERROR (Status)) {
 750     return Status;
 751   }
 752   Str += ConvertedStrLen;
 753   if (IS_HYPHEN (*Str)) {
 754     Str++;
 755   } else {
 756     return EFI_UNSUPPORTED;
 757   }
 758
 759   BufferLength = sizeof (Guid->Data3);
 760   Status = HexStringToBuf ((UINT8 *) &Guid->Data3, &BufferLength, Str, &ConvertedStrLen);
 761   if (EFI_ERROR (Status)) {
 762     return Status;
 763   }
 764   Str += ConvertedStrLen;
 765   if (IS_HYPHEN (*Str)) {
 766     Str++;
 767   } else {
 768     return EFI_UNSUPPORTED;
 769   }
 770
 771   StrToBuf (&Guid->Data4[0], 2, Str);
 772   //
 773   // Skip 2 byte hex chars
 774   //
 775   Str += 2 * 2;
 776
 777   if (IS_HYPHEN (*Str)) {
 778     Str++;
 779   } else {
 780     return EFI_UNSUPPORTED;
 781   }
 782   StrToBuf (&Guid->Data4[2], 6, Str);
 783
 784   return EFI_SUCCESS;
 785 }
 786
 787 STATIC
 788 VOID
 789 StrToIPv4Addr (
 790   IN OUT CHAR16           **Str,
 791   OUT    EFI_IPv4_ADDRESS *IPv4Addr
 792   )
 793 {
 794   UINTN  Index;
 795
 796   for (Index = 0; Index < 4; Index++) {
 797     IPv4Addr->Addr[Index] = (UINT8) Dtoi (SplitStr (Str, L'.'));
 798   }
 799 }
 800
 801 STATIC
 802 VOID
 803 StrToIPv6Addr (
 804   IN OUT CHAR16           **Str,
 805   OUT    EFI_IPv6_ADDRESS *IPv6Addr
 806   )
 807 {
 808   UINTN  Index;
 809   UINT16 Data;
 810
 811   for (Index = 0; Index < 8; Index++) {
 812     Data = (UINT16) Xtoi (SplitStr (Str, L':'));
 813     IPv6Addr->Addr[Index * 2] = (UINT8) (Data >> 8);
 814     IPv6Addr->Addr[Index * 2 + 1] = (UINT8) (Data & 0xff);
 815   }
 816 }
 817
 818 STATIC
 819 VOID
 820 StrToAscii (
 821   IN     CHAR16 *Str,
 822   IN OUT CHAR8  **AsciiStr
 823   )
 824 {
 825   CHAR8 *Dest;
 826
 827   Dest = *AsciiStr;
 828   while (!IS_NULL (*Str)) {
 829     *(Dest++) = (CHAR8) *(Str++);
 830   }
 831   *Dest = 0;
 832
 833   //
 834   // Return the string next to it
 835   //
 836   *AsciiStr = Dest + 1;
 837 }
 838
 839 STATIC
 840 EFI_DEVICE_PATH_PROTOCOL *
 841 DevPathFromTextPci (
 842   IN CHAR16 *TextDeviceNode
 843   )
 844 {
 845   CHAR16          *FunctionStr;
 846   CHAR16          *DeviceStr;
 847   PCI_DEVICE_PATH *Pci;
 848
 849   DeviceStr   = GetNextParamStr (&TextDeviceNode);
 850   FunctionStr = GetNextParamStr (&TextDeviceNode);
 851   Pci         = (PCI_DEVICE_PATH *) CreateDeviceNode (
 852                                       HARDWARE_DEVICE_PATH,
 853                                       HW_PCI_DP,
 854                                       sizeof (PCI_DEVICE_PATH)
 855                                       );
 856
 857   Pci->Function = (UINT8) Strtoi (FunctionStr);
 858   Pci->Device   = (UINT8) Strtoi (DeviceStr);
 859
 860   return (EFI_DEVICE_PATH_PROTOCOL *) Pci;
 861 }
 862
 863 STATIC
 864 EFI_DEVICE_PATH_PROTOCOL *
 865 DevPathFromTextPcCard (
 866   IN CHAR16 *TextDeviceNode
 867   )
 868 {
 869   CHAR16              *FunctionNumberStr;
 870   PCCARD_DEVICE_PATH  *Pccard;
 871
 872   FunctionNumberStr = GetNextParamStr (&TextDeviceNode);
 873   Pccard            = (PCCARD_DEVICE_PATH *) CreateDeviceNode (
 874                                                HARDWARE_DEVICE_PATH,
 875                                                HW_PCCARD_DP,
 876                                                sizeof (PCCARD_DEVICE_PATH)
 877                                                );
 878
 879   Pccard->FunctionNumber  = (UINT8) Strtoi (FunctionNumberStr);
 880
 881   return (EFI_DEVICE_PATH_PROTOCOL *) Pccard;
 882 }
 883
 884 STATIC
 885 EFI_DEVICE_PATH_PROTOCOL *
 886 DevPathFromTextMemoryMapped (
 887   IN CHAR16 *TextDeviceNode
 888   )
 889 {
 890   CHAR16              *MemoryTypeStr;
 891   CHAR16              *StartingAddressStr;
 892   CHAR16              *EndingAddressStr;
 893   MEMMAP_DEVICE_PATH  *MemMap;
 894
 895   MemoryTypeStr      = GetNextParamStr (&TextDeviceNode);
 896   StartingAddressStr = GetNextParamStr (&TextDeviceNode);
 897   EndingAddressStr   = GetNextParamStr (&TextDeviceNode);
 898   MemMap             = (MEMMAP_DEVICE_PATH *) CreateDeviceNode (
 899                                                HARDWARE_DEVICE_PATH,
 900                                                HW_MEMMAP_DP,
 901                                                sizeof (MEMMAP_DEVICE_PATH)
 902                                                );
 903
 904   MemMap->MemoryType = (UINT32) Strtoi (MemoryTypeStr);
 905   Strtoi64 (StartingAddressStr, &MemMap->StartingAddress);
 906   Strtoi64 (EndingAddressStr, &MemMap->EndingAddress);
 907
 908   return (EFI_DEVICE_PATH_PROTOCOL *) MemMap;
 909 }
 910
 911 STATIC
 912 EFI_DEVICE_PATH_PROTOCOL *
 913 ConvertFromTextVendor (
 914   IN CHAR16 *TextDeviceNode,
 915   IN UINT8  Type,
 916   IN UINT8  SubType
 917   )
 918 {
 919   CHAR16              *GuidStr;
 920   CHAR16              *DataStr;
 921   UINTN               Length;
 922   VENDOR_DEVICE_PATH  *Vendor;
 923
 924   GuidStr = GetNextParamStr (&TextDeviceNode);
 925
 926   DataStr = GetNextParamStr (&TextDeviceNode);
 927   Length  = StrLen (DataStr);
 928   //
 929   // Two hex characters make up 1 buffer byte
 930   //
 931   Length  = (Length + 1) / 2;
 932
 933   Vendor  = (VENDOR_DEVICE_PATH *) CreateDeviceNode (
 934                                      Type,
 935                                      SubType,
 936                                      (UINT16) (sizeof (VENDOR_DEVICE_PATH) + Length)
 937                                      );
 938
 939   StrToGuid (GuidStr, &Vendor->Guid);
 940   StrToBuf (((UINT8 *) Vendor) + sizeof (VENDOR_DEVICE_PATH), Length, DataStr);
 941
 942   return (EFI_DEVICE_PATH_PROTOCOL *) Vendor;
 943 }
 944
 945 STATIC
 946 EFI_DEVICE_PATH_PROTOCOL *
 947 DevPathFromTextVenHw (
 948   IN CHAR16 *TextDeviceNode
 949   )
 950 {
 951   return ConvertFromTextVendor (
 952            TextDeviceNode,
 953            HARDWARE_DEVICE_PATH,
 954            HW_VENDOR_DP
 955            );
 956 }
 957
 958 STATIC
 959 EFI_DEVICE_PATH_PROTOCOL *
 960 DevPathFromTextCtrl (
 961   IN CHAR16 *TextDeviceNode
 962   )
 963 {
 964   CHAR16                  *ControllerStr;
 965   CONTROLLER_DEVICE_PATH  *Controller;
 966
 967   ControllerStr = GetNextParamStr (&TextDeviceNode);
 968   Controller    = (CONTROLLER_DEVICE_PATH *) CreateDeviceNode (
 969                                                HARDWARE_DEVICE_PATH,
 970                                                HW_CONTROLLER_DP,
 971                                                sizeof (CONTROLLER_DEVICE_PATH)
 972                                                );
 973   Controller->ControllerNumber = (UINT32) Strtoi (ControllerStr);
 974
 975   return (EFI_DEVICE_PATH_PROTOCOL *) Controller;
 976 }
 977
 978 STATIC
 979 VOID
 980 EisaIdFromText (
 981   IN CHAR16 *Text,
 982   OUT UINT32 *EisaId
 983   )
 984 {
 985   UINTN PnpId;
 986
 987   PnpId = Xtoi (Text + 3);
 988   *EisaId = (((Text[0] - '@') & 0x1f) << 10) +
 989             (((Text[1] - '@') & 0x1f) << 5) +
 990             ((Text[2] - '@') & 0x1f) +
 991             (UINT32) (PnpId << 16);
 992 }
 993
 994 EFI_DEVICE_PATH_PROTOCOL *
 995 DevPathFromTextAcpi (
 996   IN CHAR16 *TextDeviceNode
 997   )
 998 {
 999   CHAR16                *HIDStr;
1000   CHAR16                *UIDStr;
1001   ACPI_HID_DEVICE_PATH  *Acpi;
1002
1003   HIDStr = GetNextParamStr (&TextDeviceNode);
1004   UIDStr = GetNextParamStr (&TextDeviceNode);
1005   Acpi   = (ACPI_HID_DEVICE_PATH *) CreateDeviceNode (
1006                                       ACPI_DEVICE_PATH,
1007                                       ACPI_DP,
1008                                       sizeof (ACPI_HID_DEVICE_PATH)
1009                                       );
1010
1011   EisaIdFromText (HIDStr, &Acpi->HID);
1012   Acpi->UID = (UINT32) Strtoi (UIDStr);
1013
1014   return (EFI_DEVICE_PATH_PROTOCOL *) Acpi;
1015 }
1016
1017 STATIC
1018 EFI_DEVICE_PATH_PROTOCOL *
1019 ConvertFromTextAcpi (
1020   IN CHAR16 *TextDeviceNode,
1021   IN UINT32  PnPId
1022   )
1023 {
1024   CHAR16                *UIDStr;
1025   ACPI_HID_DEVICE_PATH  *Acpi;
1026
1027   UIDStr = GetNextParamStr (&TextDeviceNode);
1028   Acpi   = (ACPI_HID_DEVICE_PATH *) CreateDeviceNode (
1029                                       ACPI_DEVICE_PATH,
1030                                       ACPI_DP,
1031                                       sizeof (ACPI_HID_DEVICE_PATH)
1032                                       );
1033
1034   Acpi->HID = EFI_PNP_ID (PnPId);
1035   Acpi->UID = (UINT32) Strtoi (UIDStr);
1036
1037   return (EFI_DEVICE_PATH_PROTOCOL *) Acpi;
1038 }
1039
1040 STATIC
1041 EFI_DEVICE_PATH_PROTOCOL *
1042 DevPathFromTextPciRoot (
1043   IN CHAR16 *TextDeviceNode
1044   )
1045 {
1046   return ConvertFromTextAcpi (TextDeviceNode, 0x0a03);
1047 }
1048
1049 STATIC
1050 EFI_DEVICE_PATH_PROTOCOL *
1051 DevPathFromTextFloppy (
1052   IN CHAR16 *TextDeviceNode
1053   )
1054 {
1055   return ConvertFromTextAcpi (TextDeviceNode, 0x0604);
1056 }
1057
1058 STATIC
1059 EFI_DEVICE_PATH_PROTOCOL *
1060 DevPathFromTextKeyboard (
1061   IN CHAR16 *TextDeviceNode
1062   )
1063 {
1064   return ConvertFromTextAcpi (TextDeviceNode, 0x0301);
1065 }
1066
1067 STATIC
1068 EFI_DEVICE_PATH_PROTOCOL *
1069 DevPathFromTextSerial (
1070   IN CHAR16 *TextDeviceNode
1071   )
1072 {
1073   return ConvertFromTextAcpi (TextDeviceNode, 0x0501);
1074 }
1075
1076 STATIC
1077 EFI_DEVICE_PATH_PROTOCOL *
1078 DevPathFromTextParallelPort (
1079   IN CHAR16 *TextDeviceNode
1080   )
1081 {
1082   return ConvertFromTextAcpi (TextDeviceNode, 0x0401);
1083 }
1084
1085 STATIC
1086 EFI_DEVICE_PATH_PROTOCOL *
1087 DevPathFromTextAcpiEx (
1088   IN CHAR16 *TextDeviceNode
1089   )
1090 {
1091   CHAR16                         *HIDStr;
1092   CHAR16                         *CIDStr;
1093   CHAR16                         *UIDStr;
1094   CHAR16                         *HIDSTRStr;
1095   CHAR16                         *CIDSTRStr;
1096   CHAR16                         *UIDSTRStr;
1097   CHAR8                          *AsciiStr;
1098   UINT16                         Length;
1099   ACPI_EXTENDED_HID_DEVICE_PATH  *AcpiEx;
1100
1101   HIDStr    = GetNextParamStr (&TextDeviceNode);
1102   CIDStr    = GetNextParamStr (&TextDeviceNode);
1103   UIDStr    = GetNextParamStr (&TextDeviceNode);
1104   HIDSTRStr = GetNextParamStr (&TextDeviceNode);
1105   CIDSTRStr = GetNextParamStr (&TextDeviceNode);
1106   UIDSTRStr = GetNextParamStr (&TextDeviceNode);
1107
1108   Length    = (UINT16) (sizeof (ACPI_EXTENDED_HID_DEVICE_PATH) + StrLen (HIDSTRStr) + 1);
1109   Length    = (UINT16) (Length + StrLen (UIDSTRStr) + 1);
1110   Length    = (UINT16) (Length + StrLen (CIDSTRStr) + 1);
1111   AcpiEx = (ACPI_EXTENDED_HID_DEVICE_PATH *) CreateDeviceNode (
1112                                                ACPI_DEVICE_PATH,
1113                                                ACPI_EXTENDED_DP,
1114                                                Length
1115                                                );
1116
1117   EisaIdFromText (HIDStr, &AcpiEx->HID);
1118   EisaIdFromText (CIDStr, &AcpiEx->CID);
1119   AcpiEx->UID = (UINT32) Strtoi (UIDStr);
1120
1121   AsciiStr = (CHAR8 *) ((UINT8 *)AcpiEx + sizeof (ACPI_EXTENDED_HID_DEVICE_PATH));
1122   StrToAscii (HIDSTRStr, &AsciiStr);
1123   StrToAscii (UIDSTRStr, &AsciiStr);
1124   StrToAscii (CIDSTRStr, &AsciiStr);
1125
1126   return (EFI_DEVICE_PATH_PROTOCOL *) AcpiEx;
1127 }
1128
1129 STATIC
1130 EFI_DEVICE_PATH_PROTOCOL *
1131 DevPathFromTextAcpiExp (
1132   IN CHAR16 *TextDeviceNode
1133   )
1134 {
1135   CHAR16                         *HIDStr;
1136   CHAR16                         *CIDStr;
1137   CHAR16                         *UIDSTRStr;
1138   CHAR8                          *AsciiStr;
1139   UINT16                         Length;
1140   ACPI_EXTENDED_HID_DEVICE_PATH  *AcpiEx;
1141
1142   HIDStr    = GetNextParamStr (&TextDeviceNode);
1143   CIDStr    = GetNextParamStr (&TextDeviceNode);
1144   UIDSTRStr = GetNextParamStr (&TextDeviceNode);
1145   Length    = (UINT16) (sizeof (ACPI_EXTENDED_HID_DEVICE_PATH) + StrLen (UIDSTRStr) + 3);
1146   AcpiEx    = (ACPI_EXTENDED_HID_DEVICE_PATH *) CreateDeviceNode (
1147                                                   ACPI_DEVICE_PATH,
1148                                                   ACPI_EXTENDED_DP,
1149                                                   Length
1150                                                   );
1151
1152   EisaIdFromText (HIDStr, &AcpiEx->HID);
1153   EisaIdFromText (CIDStr, &AcpiEx->CID);
1154   AcpiEx->UID = 0;
1155
1156   AsciiStr = (CHAR8 *) ((UINT8 *)AcpiEx + sizeof (ACPI_EXTENDED_HID_DEVICE_PATH));
1157   //
1158   // HID string is NULL
1159   //
1160   *AsciiStr = '\0';
1161   //
1162   // Convert UID string
1163   //
1164   AsciiStr++;
1165   StrToAscii (UIDSTRStr, &AsciiStr);
1166   //
1167   // CID string is NULL
1168   //
1169   *AsciiStr = '\0';
1170
1171   return (EFI_DEVICE_PATH_PROTOCOL *) AcpiEx;
1172 }
1173
1174 STATIC
1175 EFI_DEVICE_PATH_PROTOCOL *
1176 DevPathFromTextAta (
1177   IN CHAR16 *TextDeviceNode
1178   )
1179 {
1180   CHAR16            *PrimarySecondaryStr;
1181   CHAR16            *SlaveMasterStr;
1182   CHAR16            *LunStr;
1183   ATAPI_DEVICE_PATH *Atapi;
1184
1185   Atapi = (ATAPI_DEVICE_PATH *) CreateDeviceNode (
1186                                   MESSAGING_DEVICE_PATH,
1187                                   MSG_ATAPI_DP,
1188                                   sizeof (ATAPI_DEVICE_PATH)
1189                                   );
1190
1191   PrimarySecondaryStr     = GetNextParamStr (&TextDeviceNode);
1192   SlaveMasterStr          = GetNextParamStr (&TextDeviceNode);
1193   LunStr                  = GetNextParamStr (&TextDeviceNode);
1194
1195   Atapi->PrimarySecondary = (UINT8) ((StrCmp (PrimarySecondaryStr, L"Primary") == 0) ? 0 : 1);
1196   Atapi->SlaveMaster      = (UINT8) ((StrCmp (SlaveMasterStr, L"Master") == 0) ? 0 : 1);
1197   Atapi->Lun              = (UINT16) Strtoi (LunStr);
1198
1199   return (EFI_DEVICE_PATH_PROTOCOL *) Atapi;
1200 }
1201
1202 STATIC
1203 EFI_DEVICE_PATH_PROTOCOL *
1204 DevPathFromTextScsi (
1205   IN CHAR16 *TextDeviceNode
1206   )
1207 {
1208   CHAR16            *PunStr;
1209   CHAR16            *LunStr;
1210   SCSI_DEVICE_PATH  *Scsi;
1211
1212   PunStr = GetNextParamStr (&TextDeviceNode);
1213   LunStr = GetNextParamStr (&TextDeviceNode);
1214   Scsi   = (SCSI_DEVICE_PATH *) CreateDeviceNode (
1215                                    MESSAGING_DEVICE_PATH,
1216                                    MSG_SCSI_DP,
1217                                    sizeof (SCSI_DEVICE_PATH)
1218                                    );
1219
1220   Scsi->Pun = (UINT16) Strtoi (PunStr);
1221   Scsi->Lun = (UINT16) Strtoi (LunStr);
1222
1223   return (EFI_DEVICE_PATH_PROTOCOL *) Scsi;
1224 }
1225
1226 STATIC
1227 EFI_DEVICE_PATH_PROTOCOL *
1228 DevPathFromTextFibre (
1229   IN CHAR16 *TextDeviceNode
1230   )
1231 {
1232   CHAR16                    *WWNStr;
1233   CHAR16                    *LunStr;
1234   FIBRECHANNEL_DEVICE_PATH  *Fibre;
1235
1236   WWNStr = GetNextParamStr (&TextDeviceNode);
1237   LunStr = GetNextParamStr (&TextDeviceNode);
1238   Fibre  = (FIBRECHANNEL_DEVICE_PATH *) CreateDeviceNode (
1239                                           MESSAGING_DEVICE_PATH,
1240                                           MSG_FIBRECHANNEL_DP,
1241                                           sizeof (FIBRECHANNEL_DEVICE_PATH)
1242                                           );
1243
1244   Fibre->Reserved = 0;
1245   Strtoi64 (WWNStr, &Fibre->WWN);
1246   Strtoi64 (LunStr, &Fibre->Lun);
1247
1248   return (EFI_DEVICE_PATH_PROTOCOL *) Fibre;
1249 }
1250
1251 STATIC
1252 EFI_DEVICE_PATH_PROTOCOL *
1253 DevPathFromText1394 (
1254   IN CHAR16 *TextDeviceNode
1255   )
1256 {
1257   CHAR16            *GuidStr;
1258   F1394_DEVICE_PATH *F1394;
1259
1260   GuidStr = GetNextParamStr (&TextDeviceNode);
1261   F1394  = (F1394_DEVICE_PATH *) CreateDeviceNode (
1262                                    MESSAGING_DEVICE_PATH,
1263                                    MSG_1394_DP,
1264                                    sizeof (F1394_DEVICE_PATH)
1265                                    );
1266
1267   F1394->Reserved = 0;
1268   Xtoi64 (GuidStr, &F1394->Guid);
1269
1270   return (EFI_DEVICE_PATH_PROTOCOL *) F1394;
1271 }
1272
1273 STATIC
1274 EFI_DEVICE_PATH_PROTOCOL *
1275 DevPathFromTextUsb (
1276   IN CHAR16 *TextDeviceNode
1277   )
1278 {
1279   CHAR16          *PortStr;
1280   CHAR16          *InterfaceStr;
1281   USB_DEVICE_PATH *Usb;
1282
1283   PortStr               = GetNextParamStr (&TextDeviceNode);
1284   InterfaceStr          = GetNextParamStr (&TextDeviceNode);
1285   Usb                   = (USB_DEVICE_PATH *) CreateDeviceNode (
1286                                                 MESSAGING_DEVICE_PATH,
1287                                                 MSG_USB_DP,
1288                                                 sizeof (USB_DEVICE_PATH)
1289                                                 );
1290
1291   Usb->ParentPortNumber = (UINT8) Strtoi (PortStr);
1292   Usb->InterfaceNumber  = (UINT8) Strtoi (InterfaceStr);
1293
1294   return (EFI_DEVICE_PATH_PROTOCOL *) Usb;
1295 }
1296
1297 STATIC
1298 EFI_DEVICE_PATH_PROTOCOL *
1299 DevPathFromTextI2O (
1300   IN CHAR16 *TextDeviceNode
1301   )
1302 {
1303   CHAR16          *TIDStr;
1304   I2O_DEVICE_PATH *I2O;
1305
1306   TIDStr    = GetNextParamStr (&TextDeviceNode);
1307   I2O       = (I2O_DEVICE_PATH *) CreateDeviceNode (
1308                                     MESSAGING_DEVICE_PATH,
1309                                     MSG_I2O_DP,
1310                                     sizeof (I2O_DEVICE_PATH)
1311                                     );
1312
1313   I2O->Tid  = (UINT32) Strtoi (TIDStr);
1314
1315   return (EFI_DEVICE_PATH_PROTOCOL *) I2O;
1316 }
1317
1318 STATIC
1319 EFI_DEVICE_PATH_PROTOCOL *
1320 DevPathFromTextInfiniband (
1321   IN CHAR16 *TextDeviceNode
1322   )
1323 {
1324   CHAR16                  *FlagsStr;
1325   CHAR16                  *GuidStr;
1326   CHAR16                  *SidStr;
1327   CHAR16                  *TidStr;
1328   CHAR16                  *DidStr;
1329   EFI_GUID                PortGid;
1330   INFINIBAND_DEVICE_PATH  *InfiniBand;
1331
1332   FlagsStr   = GetNextParamStr (&TextDeviceNode);
1333   GuidStr    = GetNextParamStr (&TextDeviceNode);
1334   SidStr     = GetNextParamStr (&TextDeviceNode);
1335   TidStr     = GetNextParamStr (&TextDeviceNode);
1336   DidStr     = GetNextParamStr (&TextDeviceNode);
1337   InfiniBand = (INFINIBAND_DEVICE_PATH *) CreateDeviceNode (
1338                                             MESSAGING_DEVICE_PATH,
1339                                             MSG_INFINIBAND_DP,
1340                                             sizeof (INFINIBAND_DEVICE_PATH)
1341                                             );
1342
1343   InfiniBand->ResourceFlags = (UINT32) Strtoi (FlagsStr);
1344   StrToGuid (GuidStr, &PortGid);
1345   CopyMem (InfiniBand->PortGid, &PortGid, sizeof (EFI_GUID));
1346   Strtoi64 (SidStr, &InfiniBand->ServiceId);
1347   Strtoi64 (TidStr, &InfiniBand->TargetPortId);
1348   Strtoi64 (DidStr, &InfiniBand->DeviceId);
1349
1350   return (EFI_DEVICE_PATH_PROTOCOL *) InfiniBand;
1351 }
1352
1353 STATIC
1354 EFI_DEVICE_PATH_PROTOCOL *
1355 DevPathFromTextVenMsg (
1356   IN CHAR16 *TextDeviceNode
1357   )
1358 {
1359   return ConvertFromTextVendor (
1360             TextDeviceNode,
1361             MESSAGING_DEVICE_PATH,
1362             MSG_VENDOR_DP
1363             );
1364 }
1365
1366 STATIC
1367 EFI_DEVICE_PATH_PROTOCOL *
1368 DevPathFromTextVenPcAnsi (
1369   IN CHAR16 *TextDeviceNode
1370   )
1371 {
1372   VENDOR_DEVICE_PATH  *Vendor;
1373
1374   Vendor = (VENDOR_DEVICE_PATH *) CreateDeviceNode (
1375                                     MESSAGING_DEVICE_PATH,
1376                                     MSG_VENDOR_DP,
1377                                     sizeof (VENDOR_DEVICE_PATH));
1378   CopyGuid (&Vendor->Guid, &gEfiPcAnsiGuid);
1379
1380   return (EFI_DEVICE_PATH_PROTOCOL *) Vendor;
1381 }
1382
1383 STATIC
1384 EFI_DEVICE_PATH_PROTOCOL *
1385 DevPathFromTextVenVt100 (
1386   IN CHAR16 *TextDeviceNode
1387   )
1388 {
1389   VENDOR_DEVICE_PATH  *Vendor;
1390
1391   Vendor = (VENDOR_DEVICE_PATH *) CreateDeviceNode (
1392                                     MESSAGING_DEVICE_PATH,
1393                                     MSG_VENDOR_DP,
1394                                     sizeof (VENDOR_DEVICE_PATH));
1395   CopyGuid (&Vendor->Guid, &gEfiVT100Guid);
1396
1397   return (EFI_DEVICE_PATH_PROTOCOL *) Vendor;
1398 }
1399
1400 STATIC
1401 EFI_DEVICE_PATH_PROTOCOL *
1402 DevPathFromTextVenVt100Plus (
1403   IN CHAR16 *TextDeviceNode
1404   )
1405 {
1406   VENDOR_DEVICE_PATH  *Vendor;
1407
1408   Vendor = (VENDOR_DEVICE_PATH *) CreateDeviceNode (
1409                                     MESSAGING_DEVICE_PATH,
1410                                     MSG_VENDOR_DP,
1411                                     sizeof (VENDOR_DEVICE_PATH));
1412   CopyGuid (&Vendor->Guid, &gEfiVT100PlusGuid);
1413
1414   return (EFI_DEVICE_PATH_PROTOCOL *) Vendor;
1415 }
1416
1417 STATIC
1418 EFI_DEVICE_PATH_PROTOCOL *
1419 DevPathFromTextVenUtf8 (
1420   IN CHAR16 *TextDeviceNode
1421   )
1422 {
1423   VENDOR_DEVICE_PATH  *Vendor;
1424
1425   Vendor = (VENDOR_DEVICE_PATH *) CreateDeviceNode (
1426                                     MESSAGING_DEVICE_PATH,
1427                                     MSG_VENDOR_DP,
1428                                     sizeof (VENDOR_DEVICE_PATH));
1429   CopyGuid (&Vendor->Guid, &gEfiVTUTF8Guid);
1430
1431   return (EFI_DEVICE_PATH_PROTOCOL *) Vendor;
1432 }
1433
1434 STATIC
1435 EFI_DEVICE_PATH_PROTOCOL *
1436 DevPathFromTextUartFlowCtrl (
1437   IN CHAR16 *TextDeviceNode
1438   )
1439 {
1440   CHAR16                        *ValueStr;
1441   UART_FLOW_CONTROL_DEVICE_PATH *UartFlowControl;
1442
1443   ValueStr        = GetNextParamStr (&TextDeviceNode);
1444   UartFlowControl = (UART_FLOW_CONTROL_DEVICE_PATH *) CreateDeviceNode (
1445                                                         MESSAGING_DEVICE_PATH,
1446                                                         MSG_VENDOR_DP,
1447                                                         sizeof (UART_FLOW_CONTROL_DEVICE_PATH)
1448                                                         );
1449
1450   CopyGuid (&UartFlowControl->Guid, &mEfiDevicePathMessagingUartFlowControlGuid);
1451   if (StrCmp (ValueStr, L"XonXoff") == 0) {
1452     UartFlowControl->FlowControlMap = 2;
1453   } else if (StrCmp (ValueStr, L"Hardware") == 0) {
1454     UartFlowControl->FlowControlMap = 1;
1455   } else {
1456     UartFlowControl->FlowControlMap = 0;
1457   }
1458
1459   return (EFI_DEVICE_PATH_PROTOCOL *) UartFlowControl;
1460 }
1461
1462 STATIC
1463 EFI_DEVICE_PATH_PROTOCOL *
1464 DevPathFromTextSAS (
1465   IN CHAR16 *TextDeviceNode
1466   )
1467 {
1468   CHAR16          *AddressStr;
1469   CHAR16          *LunStr;
1470   CHAR16          *RTPStr;
1471   CHAR16          *SASSATAStr;
1472   CHAR16          *LocationStr;
1473   CHAR16          *ConnectStr;
1474   CHAR16          *DriveBayStr;
1475   CHAR16          *ReservedStr;
1476   UINT16          Info;
1477   SAS_DEVICE_PATH *Sas;
1478
1479   AddressStr  = GetNextParamStr (&TextDeviceNode);
1480   LunStr      = GetNextParamStr (&TextDeviceNode);
1481   RTPStr      = GetNextParamStr (&TextDeviceNode);
1482   SASSATAStr  = GetNextParamStr (&TextDeviceNode);
1483   LocationStr = GetNextParamStr (&TextDeviceNode);
1484   ConnectStr  = GetNextParamStr (&TextDeviceNode);
1485   DriveBayStr = GetNextParamStr (&TextDeviceNode);
1486   ReservedStr = GetNextParamStr (&TextDeviceNode);
1487   Info        = 0x0000;
1488   Sas         = (SAS_DEVICE_PATH *) CreateDeviceNode (
1489                                        MESSAGING_DEVICE_PATH,
1490                                        MSG_VENDOR_DP,
1491                                        sizeof (SAS_DEVICE_PATH)
1492                                        );
1493
1494   CopyGuid (&Sas->Guid, &mEfiDevicePathMessagingSASGuid);
1495   Strtoi64 (AddressStr, &Sas->SasAddress);
1496   Strtoi64 (LunStr, &Sas->Lun);
1497   Sas->RelativeTargetPort = (UINT16) Strtoi (RTPStr);
1498   if (StrCmp (SASSATAStr, L"NoTopology") != 0) {
1499     if (StrCmp (DriveBayStr, L"0") == 0) {
1500       Info |= 0x0001;
1501     } else {
1502       Info |= 0x0002;
1503       Info = (UINT16) (Info | (Strtoi (DriveBayStr) << 8));
1504     }
1505
1506     if (StrCmp (SASSATAStr, L"SATA") == 0) {
1507       Info |= 0x0010;
1508     }
1509
1510     if (StrCmp (LocationStr, L"External") == 0) {
1511       Info |= 0x0020;
1512     }
1513
1514     if (StrCmp (ConnectStr, L"Expanded") == 0) {
1515       Info |= 0x0040;
1516     }
1517   }
1518
1519   Sas->DeviceTopology = Info;
1520   Sas->Reserved       = (UINT32) Strtoi (ReservedStr);
1521
1522   return (EFI_DEVICE_PATH_PROTOCOL *) Sas;
1523 }
1524
1525 STATIC
1526 EFI_DEVICE_PATH_PROTOCOL *
1527 DevPathFromTextDebugPort (
1528   IN CHAR16 *TextDeviceNode
1529   )
1530 {
1531   VENDOR_DEFINED_MESSAGING_DEVICE_PATH  *Vend;
1532
1533   Vend = (VENDOR_DEFINED_MESSAGING_DEVICE_PATH *) CreateDeviceNode (
1534                                                     MESSAGING_DEVICE_PATH,
1535                                                     MSG_VENDOR_DP,
1536                                                     sizeof (VENDOR_DEFINED_MESSAGING_DEVICE_PATH)
1537                                                     );
1538
1539   CopyGuid (&Vend->Guid, &gEfiDebugPortProtocolGuid);
1540
1541   return (EFI_DEVICE_PATH_PROTOCOL *) Vend;
1542 }
1543
1544 STATIC
1545 EFI_DEVICE_PATH_PROTOCOL *
1546 DevPathFromTextMAC (
1547   IN CHAR16 *TextDeviceNode
1548   )
1549 {
1550   CHAR16                *AddressStr;
1551   CHAR16                *IfTypeStr;
1552   UINTN                 Length;
1553   MAC_ADDR_DEVICE_PATH  *MAC;
1554
1555   AddressStr    = GetNextParamStr (&TextDeviceNode);
1556   IfTypeStr     = GetNextParamStr (&TextDeviceNode);
1557   MAC           = (MAC_ADDR_DEVICE_PATH *) CreateDeviceNode (
1558                                               MESSAGING_DEVICE_PATH,
1559                                               MSG_MAC_ADDR_DP,
1560                                               sizeof (MAC_ADDR_DEVICE_PATH)
1561                                               );
1562
1563   MAC->IfType   = (UINT8) Strtoi (IfTypeStr);
1564
1565   Length = sizeof (EFI_MAC_ADDRESS);
1566   StrToBuf (&MAC->MacAddress.Addr[0], Length, AddressStr);
1567
1568   return (EFI_DEVICE_PATH_PROTOCOL *) MAC;
1569 }
1570
1571 STATIC
1572 EFI_DEVICE_PATH_PROTOCOL *
1573 DevPathFromTextIPv4 (
1574   IN CHAR16 *TextDeviceNode
1575   )
1576 {
1577   CHAR16            *RemoteIPStr;
1578   CHAR16            *ProtocolStr;
1579   CHAR16            *TypeStr;
1580   CHAR16            *LocalIPStr;
1581   IPv4_DEVICE_PATH  *IPv4;
1582
1583   RemoteIPStr           = GetNextParamStr (&TextDeviceNode);
1584   ProtocolStr           = GetNextParamStr (&TextDeviceNode);
1585   TypeStr               = GetNextParamStr (&TextDeviceNode);
1586   LocalIPStr            = GetNextParamStr (&TextDeviceNode);
1587   IPv4                  = (IPv4_DEVICE_PATH *) CreateDeviceNode (
1588                                                  MESSAGING_DEVICE_PATH,
1589                                                  MSG_IPv4_DP,
1590                                                  sizeof (IPv4_DEVICE_PATH)
1591                                                  );
1592
1593   StrToIPv4Addr (&RemoteIPStr, &IPv4->RemoteIpAddress);
1594   IPv4->Protocol = (UINT16) ((StrCmp (ProtocolStr, L"UDP") == 0) ? 0 : 1);
1595   if (StrCmp (TypeStr, L"Static") == 0) {
1596     IPv4->StaticIpAddress = TRUE;
1597   } else {
1598     IPv4->StaticIpAddress = FALSE;
1599   }
1600
1601   StrToIPv4Addr (&LocalIPStr, &IPv4->LocalIpAddress);
1602
1603   IPv4->LocalPort       = 0;
1604   IPv4->RemotePort      = 0;
1605
1606   return (EFI_DEVICE_PATH_PROTOCOL *) IPv4;
1607 }
1608
1609 STATIC
1610 EFI_DEVICE_PATH_PROTOCOL *
1611 DevPathFromTextIPv6 (
1612   IN CHAR16 *TextDeviceNode
1613   )
1614 {
1615   CHAR16            *RemoteIPStr;
1616   CHAR16            *ProtocolStr;
1617   CHAR16            *TypeStr;
1618   CHAR16            *LocalIPStr;
1619   IPv6_DEVICE_PATH  *IPv6;
1620
1621   RemoteIPStr           = GetNextParamStr (&TextDeviceNode);
1622   ProtocolStr           = GetNextParamStr (&TextDeviceNode);
1623   TypeStr               = GetNextParamStr (&TextDeviceNode);
1624   LocalIPStr            = GetNextParamStr (&TextDeviceNode);
1625   IPv6                  = (IPv6_DEVICE_PATH *) CreateDeviceNode (
1626                                                  MESSAGING_DEVICE_PATH,
1627                                                  MSG_IPv6_DP,
1628                                                  sizeof (IPv6_DEVICE_PATH)
1629                                                  );
1630
1631   StrToIPv6Addr (&RemoteIPStr, &IPv6->RemoteIpAddress);
1632   IPv6->Protocol        = (UINT16) ((StrCmp (ProtocolStr, L"UDP") == 0) ? 0 : 1);
1633   if (StrCmp (TypeStr, L"Static") == 0) {
1634     IPv6->StaticIpAddress = TRUE;
1635   } else {
1636     IPv6->StaticIpAddress = FALSE;
1637   }
1638
1639   StrToIPv6Addr (&LocalIPStr, &IPv6->LocalIpAddress);
1640
1641   IPv6->LocalPort       = 0;
1642   IPv6->RemotePort      = 0;
1643
1644   return (EFI_DEVICE_PATH_PROTOCOL *) IPv6;
1645 }
1646
1647 STATIC
1648 EFI_DEVICE_PATH_PROTOCOL *
1649 DevPathFromTextUart (
1650   IN CHAR16 *TextDeviceNode
1651   )
1652 {
1653   CHAR16            *BaudStr;
1654   CHAR16            *DataBitsStr;
1655   CHAR16            *ParityStr;
1656   CHAR16            *StopBitsStr;
1657   UART_DEVICE_PATH  *Uart;
1658
1659   BaudStr         = GetNextParamStr (&TextDeviceNode);
1660   DataBitsStr     = GetNextParamStr (&TextDeviceNode);
1661   ParityStr       = GetNextParamStr (&TextDeviceNode);
1662   StopBitsStr     = GetNextParamStr (&TextDeviceNode);
1663   Uart            = (UART_DEVICE_PATH *) CreateDeviceNode (
1664                                            MESSAGING_DEVICE_PATH,
1665                                            MSG_UART_DP,
1666                                            sizeof (UART_DEVICE_PATH)
1667                                            );
1668
1669   Uart->BaudRate  = (StrCmp (BaudStr, L"DEFAULT") == 0) ? 115200 : Dtoi (BaudStr);
1670   Uart->DataBits  = (UINT8) ((StrCmp (DataBitsStr, L"DEFAULT") == 0) ? 8 : Dtoi (DataBitsStr));
1671   switch (*ParityStr) {
1672   case L'D':
1673     Uart->Parity = 0;
1674     break;
1675
1676   case L'N':
1677     Uart->Parity = 1;
1678     break;
1679
1680   case L'E':
1681     Uart->Parity = 2;
1682     break;
1683
1684   case L'O':
1685     Uart->Parity = 3;
1686     break;
1687
1688   case L'M':
1689     Uart->Parity = 4;
1690     break;
1691
1692   case L'S':
1693     Uart->Parity = 5;
1694
1695   default:
1696     Uart->Parity = 0xff;
1697   }
1698
1699   if (StrCmp (StopBitsStr, L"D") == 0) {
1700     Uart->StopBits = (UINT8) 0;
1701   } else if (StrCmp (StopBitsStr, L"1") == 0) {
1702     Uart->StopBits = (UINT8) 1;
1703   } else if (StrCmp (StopBitsStr, L"1.5") == 0) {
1704     Uart->StopBits = (UINT8) 2;
1705   } else if (StrCmp (StopBitsStr, L"2") == 0) {
1706     Uart->StopBits = (UINT8) 3;
1707   } else {
1708     Uart->StopBits = 0xff;
1709   }
1710
1711   return (EFI_DEVICE_PATH_PROTOCOL *) Uart;
1712 }
1713
1714 STATIC
1715 EFI_DEVICE_PATH_PROTOCOL *
1716 ConvertFromTextUsbClass (
1717   IN CHAR16         *TextDeviceNode,
1718   IN USB_CLASS_TEXT *UsbClassText
1719   )
1720 {
1721   CHAR16                *VIDStr;
1722   CHAR16                *PIDStr;
1723   CHAR16                *ClassStr;
1724   CHAR16                *SubClassStr;
1725   CHAR16                *ProtocolStr;
1726   USB_CLASS_DEVICE_PATH *UsbClass;
1727
1728   UsbClass    = (USB_CLASS_DEVICE_PATH *) CreateDeviceNode (
1729                                             MESSAGING_DEVICE_PATH,
1730                                             MSG_USB_CLASS_DP,
1731                                             sizeof (USB_CLASS_DEVICE_PATH)
1732                                             );
1733
1734   VIDStr      = GetNextParamStr (&TextDeviceNode);
1735   PIDStr      = GetNextParamStr (&TextDeviceNode);
1736   if (UsbClassText->ClassExist) {
1737     ClassStr = GetNextParamStr (&TextDeviceNode);
1738     UsbClass->DeviceClass = (UINT8) Strtoi (ClassStr);
1739   } else {
1740     UsbClass->DeviceClass = UsbClassText->Class;
1741   }
1742   if (UsbClassText->SubClassExist) {
1743     SubClassStr = GetNextParamStr (&TextDeviceNode);
1744     UsbClass->DeviceSubClass = (UINT8) Strtoi (SubClassStr);
1745   } else {
1746     UsbClass->DeviceSubClass = UsbClassText->SubClass;
1747   }
1748
1749   ProtocolStr = GetNextParamStr (&TextDeviceNode);
1750
1751   UsbClass->VendorId        = (UINT16) Strtoi (VIDStr);
1752   UsbClass->ProductId       = (UINT16) Strtoi (PIDStr);
1753   UsbClass->DeviceProtocol  = (UINT8) Strtoi (ProtocolStr);
1754
1755   return (EFI_DEVICE_PATH_PROTOCOL *) UsbClass;
1756 }
1757
1758
1759 STATIC
1760 EFI_DEVICE_PATH_PROTOCOL *
1761 DevPathFromTextUsbClass (
1762   IN CHAR16 *TextDeviceNode
1763   )
1764 {
1765   USB_CLASS_TEXT  UsbClassText;
1766
1767   UsbClassText.ClassExist    = TRUE;
1768   UsbClassText.SubClassExist = TRUE;
1769
1770   return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1771 }
1772
1773 STATIC
1774 EFI_DEVICE_PATH_PROTOCOL *
1775 DevPathFromTextUsbAudio (
1776   IN CHAR16 *TextDeviceNode
1777   )
1778 {
1779   USB_CLASS_TEXT  UsbClassText;
1780
1781   UsbClassText.ClassExist    = FALSE;
1782   UsbClassText.Class         = USB_CLASS_AUDIO;
1783   UsbClassText.SubClassExist = TRUE;
1784
1785   return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1786 }
1787
1788 STATIC
1789 EFI_DEVICE_PATH_PROTOCOL *
1790 DevPathFromTextUsbCDCControl (
1791   IN CHAR16 *TextDeviceNode
1792   )
1793 {
1794   USB_CLASS_TEXT  UsbClassText;
1795
1796   UsbClassText.ClassExist    = FALSE;
1797   UsbClassText.Class         = USB_CLASS_CDCCONTROL;
1798   UsbClassText.SubClassExist = TRUE;
1799
1800   return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1801 }
1802
1803 STATIC
1804 EFI_DEVICE_PATH_PROTOCOL *
1805 DevPathFromTextUsbHID (
1806   IN CHAR16 *TextDeviceNode
1807   )
1808 {
1809   USB_CLASS_TEXT  UsbClassText;
1810
1811   UsbClassText.ClassExist    = FALSE;
1812   UsbClassText.Class         = USB_CLASS_HID;
1813   UsbClassText.SubClassExist = TRUE;
1814
1815   return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1816 }
1817
1818 STATIC
1819 EFI_DEVICE_PATH_PROTOCOL *
1820 DevPathFromTextUsbImage (
1821   IN CHAR16 *TextDeviceNode
1822   )
1823 {
1824   USB_CLASS_TEXT  UsbClassText;
1825
1826   UsbClassText.ClassExist    = FALSE;
1827   UsbClassText.Class         = USB_CLASS_IMAGE;
1828   UsbClassText.SubClassExist = TRUE;
1829
1830   return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1831 }
1832
1833 STATIC
1834 EFI_DEVICE_PATH_PROTOCOL *
1835 DevPathFromTextUsbPrinter (
1836   IN CHAR16 *TextDeviceNode
1837   )
1838 {
1839   USB_CLASS_TEXT  UsbClassText;
1840
1841   UsbClassText.ClassExist    = FALSE;
1842   UsbClassText.Class         = USB_CLASS_PRINTER;
1843   UsbClassText.SubClassExist = TRUE;
1844
1845   return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1846 }
1847
1848 STATIC
1849 EFI_DEVICE_PATH_PROTOCOL *
1850 DevPathFromTextUsbMassStorage (
1851   IN CHAR16 *TextDeviceNode
1852   )
1853 {
1854   USB_CLASS_TEXT  UsbClassText;
1855
1856   UsbClassText.ClassExist    = FALSE;
1857   UsbClassText.Class         = USB_CLASS_MASS_STORAGE;
1858   UsbClassText.SubClassExist = TRUE;
1859
1860   return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1861 }
1862
1863 STATIC
1864 EFI_DEVICE_PATH_PROTOCOL *
1865 DevPathFromTextUsbHub (
1866   IN CHAR16 *TextDeviceNode
1867   )
1868 {
1869   USB_CLASS_TEXT  UsbClassText;
1870
1871   UsbClassText.ClassExist    = FALSE;
1872   UsbClassText.Class         = USB_CLASS_HUB;
1873   UsbClassText.SubClassExist = TRUE;
1874
1875   return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1876 }
1877
1878 STATIC
1879 EFI_DEVICE_PATH_PROTOCOL *
1880 DevPathFromTextUsbCDCData (
1881   IN CHAR16 *TextDeviceNode
1882   )
1883 {
1884   USB_CLASS_TEXT  UsbClassText;
1885
1886   UsbClassText.ClassExist    = FALSE;
1887   UsbClassText.Class         = USB_CLASS_CDCDATA;
1888   UsbClassText.SubClassExist = TRUE;
1889
1890   return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1891 }
1892
1893 STATIC
1894 EFI_DEVICE_PATH_PROTOCOL *
1895 DevPathFromTextUsbSmartCard (
1896   IN CHAR16 *TextDeviceNode
1897   )
1898 {
1899   USB_CLASS_TEXT  UsbClassText;
1900
1901   UsbClassText.ClassExist    = FALSE;
1902   UsbClassText.Class         = USB_CLASS_SMART_CARD;
1903   UsbClassText.SubClassExist = TRUE;
1904
1905   return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1906 }
1907
1908 STATIC
1909 EFI_DEVICE_PATH_PROTOCOL *
1910 DevPathFromTextUsbVideo (
1911   IN CHAR16 *TextDeviceNode
1912   )
1913 {
1914   USB_CLASS_TEXT  UsbClassText;
1915
1916   UsbClassText.ClassExist    = FALSE;
1917   UsbClassText.Class         = USB_CLASS_VIDEO;
1918   UsbClassText.SubClassExist = TRUE;
1919
1920   return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1921 }
1922
1923 STATIC
1924 EFI_DEVICE_PATH_PROTOCOL *
1925 DevPathFromTextUsbDiagnostic (
1926   IN CHAR16 *TextDeviceNode
1927   )
1928 {
1929   USB_CLASS_TEXT  UsbClassText;
1930
1931   UsbClassText.ClassExist    = FALSE;
1932   UsbClassText.Class         = USB_CLASS_DIAGNOSTIC;
1933   UsbClassText.SubClassExist = TRUE;
1934
1935   return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1936 }
1937
1938 STATIC
1939 EFI_DEVICE_PATH_PROTOCOL *
1940 DevPathFromTextUsbWireless (
1941   IN CHAR16 *TextDeviceNode
1942   )
1943 {
1944   USB_CLASS_TEXT  UsbClassText;
1945
1946   UsbClassText.ClassExist    = FALSE;
1947   UsbClassText.Class         = USB_CLASS_WIRELESS;
1948   UsbClassText.SubClassExist = TRUE;
1949
1950   return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1951 }
1952
1953 STATIC
1954 EFI_DEVICE_PATH_PROTOCOL *
1955 DevPathFromTextUsbDeviceFirmwareUpdate (
1956   IN CHAR16 *TextDeviceNode
1957   )
1958 {
1959   USB_CLASS_TEXT  UsbClassText;
1960
1961   UsbClassText.ClassExist    = FALSE;
1962   UsbClassText.Class         = USB_CLASS_RESERVE;
1963   UsbClassText.SubClassExist = FALSE;
1964   UsbClassText.SubClass      = USB_SUBCLASS_FW_UPDATE;
1965
1966   return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1967 }
1968
1969 STATIC
1970 EFI_DEVICE_PATH_PROTOCOL *
1971 DevPathFromTextUsbIrdaBridge (
1972   IN CHAR16 *TextDeviceNode
1973   )
1974 {
1975   USB_CLASS_TEXT  UsbClassText;
1976
1977   UsbClassText.ClassExist    = FALSE;
1978   UsbClassText.Class         = USB_CLASS_RESERVE;
1979   UsbClassText.SubClassExist = FALSE;
1980   UsbClassText.SubClass      = USB_SUBCLASS_IRDA_BRIDGE;
1981
1982   return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1983 }
1984
1985 STATIC
1986 EFI_DEVICE_PATH_PROTOCOL *
1987 DevPathFromTextUsbTestAndMeasurement (
1988   IN CHAR16 *TextDeviceNode
1989   )
1990 {
1991   USB_CLASS_TEXT  UsbClassText;
1992
1993   UsbClassText.ClassExist    = FALSE;
1994   UsbClassText.Class         = USB_CLASS_RESERVE;
1995   UsbClassText.SubClassExist = FALSE;
1996   UsbClassText.SubClass      = USB_SUBCLASS_TEST;
1997
1998   return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
1999 }
2000
2001 STATIC
2002 EFI_DEVICE_PATH_PROTOCOL *
2003 DevPathFromTextUsbWwid (
2004   IN CHAR16 *TextDeviceNode
2005   )
2006 {
2007   CHAR16                *VIDStr;
2008   CHAR16                *PIDStr;
2009   CHAR16                *InterfaceNumStr;
2010   CHAR16                *SerialNumberStr;
2011   USB_WWID_DEVICE_PATH  *UsbWwid;
2012
2013   VIDStr                    = GetNextParamStr (&TextDeviceNode);
2014   PIDStr                    = GetNextParamStr (&TextDeviceNode);
2015   InterfaceNumStr           = GetNextParamStr (&TextDeviceNode);
2016   SerialNumberStr           = GetNextParamStr (&TextDeviceNode);
2017   UsbWwid                   = (USB_WWID_DEVICE_PATH *) CreateDeviceNode (
2018                                                          MESSAGING_DEVICE_PATH,
2019                                                          MSG_USB_WWID_DP,
2020                                                          (UINT16) (sizeof (USB_WWID_DEVICE_PATH) + StrSize (SerialNumberStr))
2021                                                          );
2022
2023   UsbWwid->VendorId         = (UINT16) Strtoi (VIDStr);
2024   UsbWwid->ProductId        = (UINT16) Strtoi (PIDStr);
2025   UsbWwid->InterfaceNumber  = (UINT16) Strtoi (InterfaceNumStr);
2026   StrCpy ((CHAR16 *) ((UINT8 *) UsbWwid + sizeof (USB_WWID_DEVICE_PATH)), SerialNumberStr);
2027
2028   return (EFI_DEVICE_PATH_PROTOCOL *) UsbWwid;
2029 }
2030
2031 STATIC
2032 EFI_DEVICE_PATH_PROTOCOL *
2033 DevPathFromTextUnit (
2034   IN CHAR16 *TextDeviceNode
2035   )
2036 {
2037   CHAR16                          *LunStr;
2038   DEVICE_LOGICAL_UNIT_DEVICE_PATH *LogicalUnit;
2039
2040   LunStr      = GetNextParamStr (&TextDeviceNode);
2041   LogicalUnit = (DEVICE_LOGICAL_UNIT_DEVICE_PATH *) CreateDeviceNode (
2042                                                       MESSAGING_DEVICE_PATH,
2043                                                       MSG_DEVICE_LOGICAL_UNIT_DP,
2044                                                       (UINT16) sizeof (DEVICE_LOGICAL_UNIT_DEVICE_PATH)
2045                                                       );
2046
2047   LogicalUnit->Lun  = (UINT8) Strtoi (LunStr);
2048
2049   return (EFI_DEVICE_PATH_PROTOCOL *) LogicalUnit;
2050 }
2051
2052 STATIC
2053 EFI_DEVICE_PATH_PROTOCOL *
2054 DevPathFromTextiSCSI (
2055   IN CHAR16 *TextDeviceNode
2056   )
2057 {
2058   UINT16                      Options;
2059   CHAR16                      *NameStr;
2060   CHAR16                      *PortalGroupStr;
2061   CHAR16                      *LunStr;
2062   CHAR16                      *HeaderDigestStr;
2063   CHAR16                      *DataDigestStr;
2064   CHAR16                      *AuthenticationStr;
2065   CHAR16                      *ProtocolStr;
2066   CHAR8                       *AsciiStr;
2067   ISCSI_DEVICE_PATH_WITH_NAME *iSCSI;
2068
2069   NameStr           = GetNextParamStr (&TextDeviceNode);
2070   PortalGroupStr    = GetNextParamStr (&TextDeviceNode);
2071   LunStr            = GetNextParamStr (&TextDeviceNode);
2072   HeaderDigestStr   = GetNextParamStr (&TextDeviceNode);
2073   DataDigestStr     = GetNextParamStr (&TextDeviceNode);
2074   AuthenticationStr = GetNextParamStr (&TextDeviceNode);
2075   ProtocolStr       = GetNextParamStr (&TextDeviceNode);
2076   iSCSI             = (ISCSI_DEVICE_PATH_WITH_NAME *) CreateDeviceNode (
2077                                                         MESSAGING_DEVICE_PATH,
2078                                                         MSG_ISCSI_DP,
2079                                                         (UINT16) (sizeof (ISCSI_DEVICE_PATH_WITH_NAME) + StrLen (NameStr) * 2)
2080                                                         );
2081
2082   AsciiStr = iSCSI->iSCSITargetName;
2083   StrToAscii (NameStr, &AsciiStr);
2084
2085   iSCSI->TargetPortalGroupTag = (UINT16) Strtoi (PortalGroupStr);
2086   Strtoi64 (LunStr, &iSCSI->Lun);
2087
2088   Options = 0x0000;
2089   if (StrCmp (HeaderDigestStr, L"CRC32C") == 0) {
2090     Options |= 0x0002;
2091   }
2092
2093   if (StrCmp (DataDigestStr, L"CRC32C") == 0) {
2094     Options |= 0x0008;
2095   }
2096
2097   if (StrCmp (AuthenticationStr, L"None") == 0) {
2098     Options |= 0x0800;
2099   }
2100
2101   if (StrCmp (AuthenticationStr, L"CHAP_UNI") == 0) {
2102     Options |= 0x1000;
2103   }
2104
2105   iSCSI->LoginOption      = (UINT16) Options;
2106
2107   iSCSI->NetworkProtocol  = (UINT16) StrCmp (ProtocolStr, L"TCP");
2108
2109   return (EFI_DEVICE_PATH_PROTOCOL *) iSCSI;
2110 }
2111
2112 STATIC
2113 EFI_DEVICE_PATH_PROTOCOL *
2114 DevPathFromTextHD (
2115   IN CHAR16 *TextDeviceNode
2116   )
2117 {
2118   CHAR16                *PartitionStr;
2119   CHAR16                *TypeStr;
2120   CHAR16                *SignatureStr;
2121   CHAR16                *StartStr;
2122   CHAR16                *SizeStr;
2123   UINT32                Signature32;
2124   EFI_GUID              SignatureGuid;
2125   HARDDRIVE_DEVICE_PATH *Hd;
2126
2127   PartitionStr        = GetNextParamStr (&TextDeviceNode);
2128   TypeStr             = GetNextParamStr (&TextDeviceNode);
2129   SignatureStr        = GetNextParamStr (&TextDeviceNode);
2130   StartStr            = GetNextParamStr (&TextDeviceNode);
2131   SizeStr             = GetNextParamStr (&TextDeviceNode);
2132   Hd                  = (HARDDRIVE_DEVICE_PATH *) CreateDeviceNode (
2133                                                     MEDIA_DEVICE_PATH,
2134                                                     MEDIA_HARDDRIVE_DP,
2135                                                     sizeof (HARDDRIVE_DEVICE_PATH)
2136                                                     );
2137
2138   Hd->PartitionNumber = (UINT32) Dtoi (PartitionStr);
2139
2140   ZeroMem (Hd->Signature, 16);
2141   Hd->MBRType = (UINT8) 0;
2142
2143   if (StrCmp (TypeStr, L"MBR") == 0) {
2144     Hd->SignatureType = SIGNATURE_TYPE_MBR;
2145     Hd->MBRType       = 0x01;
2146
2147     Signature32       = (UINT32) Strtoi (SignatureStr);
2148     CopyMem (Hd->Signature, &Signature32, sizeof (UINT32));
2149   } else if (StrCmp (TypeStr, L"GPT") == 0) {
2150     Hd->SignatureType = SIGNATURE_TYPE_GUID;
2151     Hd->MBRType       = 0x02;
2152
2153     StrToGuid (SignatureStr, &SignatureGuid);
2154     CopyMem (Hd->Signature, &SignatureGuid, sizeof (EFI_GUID));
2155   } else {
2156     Hd->SignatureType = (UINT8) Strtoi (TypeStr);
2157   }
2158
2159   Strtoi64 (StartStr, &Hd->PartitionStart);
2160   Strtoi64 (SizeStr, &Hd->PartitionSize);
2161
2162   return (EFI_DEVICE_PATH_PROTOCOL *) Hd;
2163 }
2164
2165 STATIC
2166 EFI_DEVICE_PATH_PROTOCOL *
2167 DevPathFromTextCDROM (
2168   IN CHAR16 *TextDeviceNode
2169   )
2170 {
2171   CHAR16            *EntryStr;
2172   CHAR16            *StartStr;
2173   CHAR16            *SizeStr;
2174   CDROM_DEVICE_PATH *CDROM;
2175
2176   EntryStr              = GetNextParamStr (&TextDeviceNode);
2177   StartStr              = GetNextParamStr (&TextDeviceNode);
2178   SizeStr               = GetNextParamStr (&TextDeviceNode);
2179   CDROM                 = (CDROM_DEVICE_PATH *) CreateDeviceNode (
2180                                                   MEDIA_DEVICE_PATH,
2181                                                   MEDIA_CDROM_DP,
2182                                                   sizeof (CDROM_DEVICE_PATH)
2183                                                   );
2184
2185   CDROM->BootEntry      = (UINT32) Strtoi (EntryStr);
2186   Strtoi64 (StartStr, &CDROM->PartitionStart);
2187   Strtoi64 (SizeStr, &CDROM->PartitionSize);
2188
2189   return (EFI_DEVICE_PATH_PROTOCOL *) CDROM;
2190 }
2191
2192 STATIC
2193 EFI_DEVICE_PATH_PROTOCOL *
2194 DevPathFromTextVenMEDIA (
2195   IN CHAR16 *TextDeviceNode
2196   )
2197 {
2198   return ConvertFromTextVendor (
2199            TextDeviceNode,
2200            MEDIA_DEVICE_PATH,
2201            MEDIA_VENDOR_DP
2202            );
2203 }
2204
2205 STATIC
2206 EFI_DEVICE_PATH_PROTOCOL *
2207 DevPathFromTextFilePath (
2208   IN CHAR16 *TextDeviceNode
2209   )
2210 {
2211   FILEPATH_DEVICE_PATH  *File;
2212
2213   File = (FILEPATH_DEVICE_PATH *) CreateDeviceNode (
2214                                     MEDIA_DEVICE_PATH,
2215                                     MEDIA_FILEPATH_DP,
2216                                     (UINT16) (sizeof (FILEPATH_DEVICE_PATH) + StrLen (TextDeviceNode) * 2)
2217                                     );
2218
2219   StrCpy (File->PathName, TextDeviceNode);
2220
2221   return (EFI_DEVICE_PATH_PROTOCOL *) File;
2222 }
2223
2224 STATIC
2225 EFI_DEVICE_PATH_PROTOCOL *
2226 DevPathFromTextMedia (
2227   IN CHAR16 *TextDeviceNode
2228   )
2229 {
2230   CHAR16                      *GuidStr;
2231   MEDIA_PROTOCOL_DEVICE_PATH  *Media;
2232
2233   GuidStr = GetNextParamStr (&TextDeviceNode);
2234   Media   = (MEDIA_PROTOCOL_DEVICE_PATH *) CreateDeviceNode (
2235                                              MEDIA_DEVICE_PATH,
2236                                              MEDIA_PROTOCOL_DP,
2237                                              sizeof (MEDIA_PROTOCOL_DEVICE_PATH)
2238                                              );
2239
2240   StrToGuid (GuidStr, &Media->Protocol);
2241
2242   return (EFI_DEVICE_PATH_PROTOCOL *) Media;
2243 }
2244
2245 STATIC
2246 EFI_DEVICE_PATH_PROTOCOL *
2247 DevPathFromTextFv (
2248   IN CHAR16 *TextDeviceNode
2249   )
2250 {
2251   CHAR16                    *GuidStr;
2252   MEDIA_FW_VOL_DEVICE_PATH  *Fv;
2253
2254   GuidStr = GetNextParamStr (&TextDeviceNode);
2255   Fv      = (MEDIA_FW_VOL_DEVICE_PATH *) CreateDeviceNode (
2256                                            MEDIA_DEVICE_PATH,
2257                                            MEDIA_PIWG_FW_VOL_DP,
2258                                            sizeof (MEDIA_FW_VOL_DEVICE_PATH)
2259                                            );
2260
2261   StrToGuid (GuidStr, &Fv->FvName);
2262
2263   return (EFI_DEVICE_PATH_PROTOCOL *) Fv;
2264 }
2265
2266 STATIC
2267 EFI_DEVICE_PATH_PROTOCOL *
2268 DevPathFromTextFvFile (
2269   IN CHAR16 *TextDeviceNode
2270   )
2271 {
2272   CHAR16                             *GuidStr;
2273   MEDIA_FW_VOL_FILEPATH_DEVICE_PATH  *FvFile;
2274
2275   GuidStr = GetNextParamStr (&TextDeviceNode);
2276   FvFile  = (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) CreateDeviceNode (
2277                                                     MEDIA_DEVICE_PATH,
2278                                                     MEDIA_PIWG_FW_FILE_DP,
2279                                                     sizeof (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH)
2280                                                     );
2281
2282   StrToGuid (GuidStr, &FvFile->FvFileName);
2283
2284   return (EFI_DEVICE_PATH_PROTOCOL *) FvFile;
2285 }
2286
2287 STATIC
2288 EFI_DEVICE_PATH_PROTOCOL *
2289 DevPathFromTextBBS (
2290   IN CHAR16 *TextDeviceNode
2291   )
2292 {
2293   CHAR16              *TypeStr;
2294   CHAR16              *IdStr;
2295   CHAR16              *FlagsStr;
2296   CHAR8               *AsciiStr;
2297   BBS_BBS_DEVICE_PATH *Bbs;
2298
2299   TypeStr   = GetNextParamStr (&TextDeviceNode);
2300   IdStr     = GetNextParamStr (&TextDeviceNode);
2301   FlagsStr  = GetNextParamStr (&TextDeviceNode);
2302   Bbs       = (BBS_BBS_DEVICE_PATH *) CreateDeviceNode (
2303                                         BBS_DEVICE_PATH,
2304                                         BBS_BBS_DP,
2305                                         (UINT16) (sizeof (BBS_BBS_DEVICE_PATH) + StrLen (IdStr))
2306                                         );
2307
2308   if (StrCmp (TypeStr, L"Floppy") == 0) {
2309     Bbs->DeviceType = BBS_TYPE_FLOPPY;
2310   } else if (StrCmp (TypeStr, L"HD") == 0) {
2311     Bbs->DeviceType = BBS_TYPE_HARDDRIVE;
2312   } else if (StrCmp (TypeStr, L"CDROM") == 0) {
2313     Bbs->DeviceType = BBS_TYPE_CDROM;
2314   } else if (StrCmp (TypeStr, L"PCMCIA") == 0) {
2315     Bbs->DeviceType = BBS_TYPE_PCMCIA;
2316   } else if (StrCmp (TypeStr, L"USB") == 0) {
2317     Bbs->DeviceType = BBS_TYPE_USB;
2318   } else if (StrCmp (TypeStr, L"Network") == 0) {
2319     Bbs->DeviceType = BBS_TYPE_EMBEDDED_NETWORK;
2320   } else {
2321     Bbs->DeviceType = (UINT16) Strtoi (TypeStr);
2322   }
2323
2324   AsciiStr = Bbs->String;
2325   StrToAscii (IdStr, &AsciiStr);
2326
2327   Bbs->StatusFlag = (UINT16) Strtoi (FlagsStr);
2328
2329   return (EFI_DEVICE_PATH_PROTOCOL *) Bbs;
2330 }
2331
2332 STATIC
2333 EFI_DEVICE_PATH_PROTOCOL *
2334 DevPathFromTextSata (
2335   IN CHAR16 *TextDeviceNode
2336   )
2337 {
2338   SATA_DEVICE_PATH *Sata;
2339   CHAR16           *Param1;
2340   CHAR16           *Param2;
2341   CHAR16           *Param3;
2342
2343   //
2344   // The PMPN is optional.
2345   //
2346   Param1 = GetNextParamStr (&TextDeviceNode);
2347   Param2 = GetNextParamStr (&TextDeviceNode);
2348   Param3 = NULL;
2349   if (!IS_NULL (TextDeviceNode)) {
2350     Param3 = GetNextParamStr (&TextDeviceNode);
2351   }
2352
2353   Sata = (SATA_DEVICE_PATH *) CreateDeviceNode (
2354                                 MESSAGING_DEVICE_PATH,
2355                                 MSG_SATA_DP,
2356                                 sizeof (SATA_DEVICE_PATH)
2357                                 );
2358   Sata->HbaPortNumber = (UINT16) Xtoi (Param1);
2359   if (Param3 != NULL) {
2360     Sata->PortMultiplierPort = (UINT16) Xtoi (Param2);
2361     Param2                   = Param3;
2362   } else {
2363     Sata->PortMultiplierPort = 0;
2364   }
2365   Sata->LogicalUnitNumber = (UINT16) Xtoi (Param2);
2366
2367   return (EFI_DEVICE_PATH_PROTOCOL *) Sata;
2368 }
2369
2370 GLOBAL_REMOVE_IF_UNREFERENCED DEVICE_PATH_FROM_TEXT_TABLE DevPathFromTextTable[] = {
2371   {L"Pci", DevPathFromTextPci},
2372   {L"PcCard", DevPathFromTextPcCard},
2373   {L"MemoryMapped", DevPathFromTextMemoryMapped},
2374   {L"VenHw", DevPathFromTextVenHw},
2375   {L"Ctrl", DevPathFromTextCtrl},
2376   {L"Acpi", DevPathFromTextAcpi},
2377   {L"PciRoot", DevPathFromTextPciRoot},
2378   {L"Floppy", DevPathFromTextFloppy},
2379   {L"Keyboard", DevPathFromTextKeyboard},
2380   {L"Serial", DevPathFromTextSerial},
2381   {L"ParallelPort", DevPathFromTextParallelPort},
2382   {L"AcpiEx", DevPathFromTextAcpiEx},
2383   {L"AcpiExp", DevPathFromTextAcpiExp},
2384   {L"Ata", DevPathFromTextAta},
2385   {L"Scsi", DevPathFromTextScsi},
2386   {L"Fibre", DevPathFromTextFibre},
2387   {L"I1394", DevPathFromText1394},
2388   {L"USB", DevPathFromTextUsb},
2389   {L"I2O", DevPathFromTextI2O},
2390   {L"Infiniband", DevPathFromTextInfiniband},
2391   {L"VenMsg", DevPathFromTextVenMsg},
2392   {L"VenPcAnsi", DevPathFromTextVenPcAnsi},
2393   {L"VenVt100", DevPathFromTextVenVt100},
2394   {L"VenVt100Plus", DevPathFromTextVenVt100Plus},
2395   {L"VenUtf8", DevPathFromTextVenUtf8},
2396   {L"UartFlowCtrl", DevPathFromTextUartFlowCtrl},
2397   {L"SAS", DevPathFromTextSAS},
2398   {L"DebugPort", DevPathFromTextDebugPort},
2399   {L"MAC", DevPathFromTextMAC},
2400   {L"IPv4", DevPathFromTextIPv4},
2401   {L"IPv6", DevPathFromTextIPv6},
2402   {L"Uart", DevPathFromTextUart},
2403   {L"UsbClass", DevPathFromTextUsbClass},
2404   {L"UsbAudio", DevPathFromTextUsbAudio},
2405   {L"UsbCDCControl", DevPathFromTextUsbCDCControl},
2406   {L"UsbHID", DevPathFromTextUsbHID},
2407   {L"UsbImage", DevPathFromTextUsbImage},
2408   {L"UsbPrinter", DevPathFromTextUsbPrinter},
2409   {L"UsbMassStorage", DevPathFromTextUsbMassStorage},
2410   {L"UsbHub", DevPathFromTextUsbHub},
2411   {L"UsbCDCData", DevPathFromTextUsbCDCData},
2412   {L"UsbSmartCard", DevPathFromTextUsbSmartCard},
2413   {L"UsbVideo", DevPathFromTextUsbVideo},
2414   {L"UsbDiagnostic", DevPathFromTextUsbDiagnostic},
2415   {L"UsbWireless", DevPathFromTextUsbWireless},
2416   {L"UsbDeviceFirmwareUpdate", DevPathFromTextUsbDeviceFirmwareUpdate},
2417   {L"UsbIrdaBridge", DevPathFromTextUsbIrdaBridge},
2418   {L"UsbTestAndMeasurement", DevPathFromTextUsbTestAndMeasurement},
2419   {L"UsbWwid", DevPathFromTextUsbWwid},
2420   {L"Unit", DevPathFromTextUnit},
2421   {L"iSCSI", DevPathFromTextiSCSI},
2422   {L"HD", DevPathFromTextHD},
2423   {L"CDROM", DevPathFromTextCDROM},
2424   {L"VenMEDIA", DevPathFromTextVenMEDIA},
2425   {L"Media", DevPathFromTextMedia},
2426   {L"Fv", DevPathFromTextFv},
2427   {L"FvFile", DevPathFromTextFvFile},
2428   {L"BBS", DevPathFromTextBBS},
2429   {L"Sata", DevPathFromTextSata},
2430   {NULL, NULL}
2431 };
2432
2433 EFI_DEVICE_PATH_PROTOCOL *
2434 ConvertTextToDeviceNode (
2435   IN CONST CHAR16 *TextDeviceNode
2436   )
2437 /*++
2438
2439   Routine Description:
2440     Convert text to the binary representation of a device node.
2441
2442   Arguments:
2443     TextDeviceNode   -   TextDeviceNode points to the text representation of a device
2444                          node. Conversion starts with the first character and continues
2445                          until the first non-device node character.
2446
2447   Returns:
2448     A pointer        -   Pointer to the EFI device node.
2449     NULL             -   If TextDeviceNode is NULL or there was insufficient memory or text unsupported.
2450
2451 --*/
2452 {
2453   EFI_DEVICE_PATH_PROTOCOL * (*DumpNode) (CHAR16 *);
2454   CHAR16                   *ParamStr;
2455   EFI_DEVICE_PATH_PROTOCOL *DeviceNode;
2456   CHAR16                   *DeviceNodeStr;
2457   UINTN                    Index;
2458
2459   if ((TextDeviceNode == NULL) || (IS_NULL (*TextDeviceNode))) {
2460     return NULL;
2461   }
2462
2463   ParamStr      = NULL;
2464   DumpNode      = NULL;
2465   DeviceNodeStr = StrDuplicate (TextDeviceNode);
2466
2467   for (Index = 0; DevPathFromTextTable[Index].Function; Index++) {
2468     ParamStr = GetParamByNodeName (DeviceNodeStr, DevPathFromTextTable[Index].DevicePathNodeText);
2469     if (ParamStr != NULL) {
2470       DumpNode = DevPathFromTextTable[Index].Function;
2471       break;
2472     }
2473   }
2474
2475   if (DumpNode == NULL) {
2476     //
2477     // A file path
2478     //
2479     DumpNode = DevPathFromTextFilePath;
2480     DeviceNode = DumpNode (DeviceNodeStr);
2481   } else {
2482     DeviceNode = DumpNode (ParamStr);
2483     FreePool (ParamStr);
2484   }
2485
2486   FreePool (DeviceNodeStr);
2487
2488   return DeviceNode;
2489 }
2490
2491 EFI_DEVICE_PATH_PROTOCOL *
2492 ConvertTextToDevicePath (
2493   IN CONST CHAR16 *TextDevicePath
2494   )
2495 /*++
2496
2497   Routine Description:
2498     Convert text to the binary representation of a device path.
2499
2500   Arguments:
2501     TextDevicePath   -   TextDevicePath points to the text representation of a device
2502                          path. Conversion starts with the first character and continues
2503                          until the first non-device node character.
2504
2505   Returns:
2506     A pointer        -   Pointer to the allocated device path.
2507     NULL             -   If TextDeviceNode is NULL or there was insufficient memory.
2508
2509 --*/
2510 {
2511   EFI_DEVICE_PATH_PROTOCOL * (*DumpNode) (CHAR16 *);
2512   CHAR16                   *ParamStr;
2513   EFI_DEVICE_PATH_PROTOCOL *DeviceNode;
2514   UINTN                    Index;
2515   EFI_DEVICE_PATH_PROTOCOL *NewDevicePath;
2516   CHAR16                   *DevicePathStr;
2517   CHAR16                   *Str;
2518   CHAR16                   *DeviceNodeStr;
2519   UINT8                    IsInstanceEnd;
2520   EFI_DEVICE_PATH_PROTOCOL *DevicePath;
2521
2522   if ((TextDevicePath == NULL) || (IS_NULL (*TextDevicePath))) {
2523     return NULL;
2524   }
2525
2526   DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) AllocatePool (END_DEVICE_PATH_LENGTH);
2527   SetDevicePathEndNode (DevicePath);
2528
2529   ParamStr            = NULL;
2530   DeviceNodeStr       = NULL;
2531   DevicePathStr       = StrDuplicate (TextDevicePath);
2532
2533   Str                 = DevicePathStr;
2534   while ((DeviceNodeStr = GetNextDeviceNodeStr (&Str, &IsInstanceEnd)) != NULL) {
2535     DumpNode = NULL;
2536     for (Index = 0; DevPathFromTextTable[Index].Function; Index++) {
2537       ParamStr = GetParamByNodeName (DeviceNodeStr, DevPathFromTextTable[Index].DevicePathNodeText);
2538       if (ParamStr != NULL) {
2539         DumpNode = DevPathFromTextTable[Index].Function;
2540         break;
2541       }
2542     }
2543
2544     if (DumpNode == NULL) {
2545       //
2546       // A file path
2547       //
2548       DumpNode  = DevPathFromTextFilePath;
2549       DeviceNode = DumpNode (DeviceNodeStr);
2550     } else {
2551       DeviceNode = DumpNode (ParamStr);
2552       FreePool (ParamStr);
2553     }
2554
2555     NewDevicePath = AppendDeviceNodeProtocolInterface (DevicePath, DeviceNode);
2556     FreePool (DevicePath);
2557     FreePool (DeviceNode);
2558     DevicePath = NewDevicePath;
2559
2560     if (IsInstanceEnd) {
2561       DeviceNode = (EFI_DEVICE_PATH_PROTOCOL *) AllocatePool (END_DEVICE_PATH_LENGTH);
2562       SetDevicePathInstanceEndNode (DeviceNode);
2563
2564       NewDevicePath = AppendDeviceNodeProtocolInterface (DevicePath, DeviceNode);
2565       FreePool (DevicePath);
2566       FreePool (DeviceNode);
2567       DevicePath = NewDevicePath;
2568     }
2569   }
2570
2571   FreePool (DevicePathStr);
2572   return DevicePath;
2573 }