MdeModulePkg/Universal/DevicePathDxe/DevicePathFromText.c

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