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