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