From: "Gao, Liming" <liming.gao@intel.com>
To: "Zhu, Yonghong" <yonghong.zhu@intel.com>,
"edk2-devel@lists.01.org" <edk2-devel@lists.01.org>
Cc: "Feng, YunhuaX" <yunhuax.feng@intel.com>
Subject: Re: [Patch 2/2] BaseTools: Add DevicePath support for PCD values
Date: Wed, 27 Dec 2017 02:40:03 +0000 [thread overview]
Message-ID: <4A89E2EF3DFEDB4C8BFDE51014F606A14E198EB9@SHSMSX104.ccr.corp.intel.com> (raw)
In-Reply-To: <1514306413-5880-3-git-send-email-yonghong.zhu@intel.com>
Yonghong:
For DevicePath definition, please define them in BaseTools\Source\C\Include\Protocol directory to align MdePkg layout.
Thanks
Liming
>-----Original Message-----
>From: edk2-devel [mailto:edk2-devel-bounces@lists.01.org] On Behalf Of
>Yonghong Zhu
>Sent: Wednesday, December 27, 2017 12:40 AM
>To: edk2-devel@lists.01.org
>Cc: Feng, YunhuaX <yunhuax.feng@intel.com>
>Subject: [edk2] [Patch 2/2] BaseTools: Add DevicePath support for PCD values
>
>Use C code parse device path to output hex string, and Python
>run command when PCD Value need device path parse.
>
>https://bugzilla.tianocore.org/show_bug.cgi?id=541
>
>Contributed-under: TianoCore Contribution Agreement 1.1
>Signed-off-by: Yunhua Feng <yunhuax.feng@intel.com>
>Signed-off-by: Yonghong Zhu <yonghong.zhu@intel.com>
>---
> BaseTools/Source/BinaryFiles.txt | 3 +-
> BaseTools/Source/C/DevicePath/DevicePath.c | 188 ++
> BaseTools/Source/C/DevicePath/DevicePath.h | 1404 ++++++++
> BaseTools/Source/C/DevicePath/DevicePathFromText.c | 3503
>++++++++++++++++++++
> BaseTools/Source/C/DevicePath/DevicePathFromText.h | 72 +
> .../Source/C/DevicePath/DevicePathUtilities.c | 2352 +++++++++++++
> .../Source/C/DevicePath/DevicePathUtilities.h | 555 ++++
> BaseTools/Source/C/DevicePath/GNUmakefile | 30 +
> BaseTools/Source/C/DevicePath/Makefile | 24 +
> BaseTools/Source/C/DevicePath/UefiDevicePathLib.c | 298 ++
> BaseTools/Source/C/DevicePath/UefiDevicePathLib.h | 473 +++
> BaseTools/Source/C/GNUmakefile | 3 +-
> BaseTools/Source/C/Makefile | 5 +-
> BaseTools/Source/Python/Common/Misc.py | 35 +-
> BaseTools/Source/Python/Workspace/DscBuildData.py | 2 +-
> 15 files changed, 8940 insertions(+), 7 deletions(-)
> create mode 100644 BaseTools/Source/C/DevicePath/DevicePath.c
> create mode 100644 BaseTools/Source/C/DevicePath/DevicePath.h
> create mode 100644 BaseTools/Source/C/DevicePath/DevicePathFromText.c
> create mode 100644 BaseTools/Source/C/DevicePath/DevicePathFromText.h
> create mode 100644 BaseTools/Source/C/DevicePath/DevicePathUtilities.c
> create mode 100644 BaseTools/Source/C/DevicePath/DevicePathUtilities.h
> create mode 100644 BaseTools/Source/C/DevicePath/GNUmakefile
> create mode 100644 BaseTools/Source/C/DevicePath/Makefile
> create mode 100644 BaseTools/Source/C/DevicePath/UefiDevicePathLib.c
> create mode 100644 BaseTools/Source/C/DevicePath/UefiDevicePathLib.h
>
>diff --git a/BaseTools/Source/BinaryFiles.txt
>b/BaseTools/Source/BinaryFiles.txt
>index 7b014a7..a5273d4 100644
>--- a/BaseTools/Source/BinaryFiles.txt
>+++ b/BaseTools/Source/BinaryFiles.txt
>@@ -9,11 +9,11 @@
> # [ExtraFiles.Win32] section.
> # The [CxFreeze.Win32] section is maintained by the owner of the Build
>Server who
> # must ensure that files that are required by the cx_freeze frozen binaries
>are
> # present in the Bin\Win32 directory.
> #
>-# Copyright (c) 2014 - 2016, Intel Corporation. All rights reserved.<BR>
>+# Copyright (c) 2014 - 2017, Intel Corporation. All rights reserved.<BR>
> #
> # This program and the accompanying materials are licensed and made
>available under
> # the terms and conditions of the BSD License which accompanies this
>distribution.
> # The full text of the license may be found at:
> # http://opensource.org/licenses/bsd-license.php
>@@ -57,10 +57,11 @@ TianoCompress.exe
> Trim.exe
> UPT.exe
> VfrCompile.exe
> VolInfo.exe
> Pkcs7Sign.exe
>+DevicePath.exe
>
> [ExtraFiles.Win32]
> TestSigningPrivateKey.pem
> config.ini
> exception.xml
>diff --git a/BaseTools/Source/C/DevicePath/DevicePath.c
>b/BaseTools/Source/C/DevicePath/DevicePath.c
>new file mode 100644
>index 0000000..6c32ad4
>--- /dev/null
>+++ b/BaseTools/Source/C/DevicePath/DevicePath.c
>@@ -0,0 +1,188 @@
>+/** @file
>+ Definition for Device Path Tool.
>+
>+Copyright (c) 2017, Intel Corporation. All rights reserved.<BR>
>+This program and the accompanying materials
>+are licensed and made available under the terms and conditions of the BSD
>License
>+which accompanies this distribution. The full text of the license may be
>found at
>+http://opensource.org/licenses/bsd-license.php
>+
>+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+**/
>+
>+#include "UefiDevicePathLib.h"
>+
>+//
>+// Utility Name
>+//
>+#define UTILITY_NAME "DevicePath"
>+
>+//
>+// Utility version information
>+//
>+#define UTILITY_MAJOR_VERSION 0
>+#define UTILITY_MINOR_VERSION 1
>+
>+EFI_GUID gEfiDebugPortDevicePathGuid =
>DEVICE_PATH_MESSAGING_DEBUGPORT;
>+EFI_GUID gEfiPcAnsiGuid = EFI_PC_ANSI_GUID;
>+EFI_GUID gEfiVT100Guid = EFI_VT_100_GUID;
>+EFI_GUID gEfiVT100PlusGuid = EFI_VT_100_PLUS_GUID;
>+EFI_GUID gEfiVTUTF8Guid = EFI_VT_UTF8_GUID;
>+EFI_GUID gEfiUartDevicePathGuid = EFI_UART_DEVICE_PATH_GUID;
>+EFI_GUID gEfiSasDevicePathGuid = EFI_SAS_DEVICE_PATH_GUID;
>+EFI_GUID gEfiVirtualDiskGuid = { 0x77AB535A, 0x45FC, 0x624B, {0x55, 0x60,
>0xF7, 0xB2, 0x81, 0xD1, 0xF9, 0x6E }};
>+EFI_GUID gEfiVirtualCdGuid = { 0x3D5ABD30, 0x4175, 0x87CE, {0x6D, 0x64,
>0xD2, 0xAD, 0xE5, 0x23, 0xC4, 0xBB }};
>+EFI_GUID gEfiPersistentVirtualDiskGuid = { 0x5CEA02C9, 0x4D07, 0x69D3,
>{0x26, 0x9F ,0x44, 0x96, 0xFB, 0xE0, 0x96, 0xF9 }};
>+EFI_GUID gEfiPersistentVirtualCdGuid = { 0x08018188, 0x42CD, 0xBB48, {0x10,
>0x0F, 0x53, 0x87, 0xD5, 0x3D, 0xED, 0x3D }};
>+
>+STATIC
>+VOID
>+Version (
>+ VOID
>+)
>+/*++
>+
>+Routine Description:
>+
>+ Displays the standard utility information to SDTOUT
>+
>+Arguments:
>+
>+ None
>+
>+Returns:
>+
>+ None
>+
>+--*/
>+{
>+ fprintf (stdout, "%s Version %d.%d %s \n", UTILITY_NAME,
>UTILITY_MAJOR_VERSION, UTILITY_MINOR_VERSION, __BUILD_VERSION);
>+}
>+
>+STATIC
>+VOID
>+Usage (
>+ VOID
>+ )
>+/*++
>+
>+Routine Description:
>+
>+ Displays the utility usage syntax to STDOUT
>+
>+Arguments:
>+
>+ None
>+
>+Returns:
>+
>+ None
>+
>+--*/
>+{
>+ //
>+ // Summary usage
>+ //
>+ fprintf (stdout, "\nUsage: %s [options]\n\n", UTILITY_NAME);
>+
>+ //
>+ // Copyright declaration
>+ //
>+ fprintf (stdout, "Copyright (c) 2007 - 2018, Intel Corporation. All rights
>reserved.\n\n");
>+ //
>+ // Details Option
>+ //
>+ fprintf (stdout, "Options:\n");
>+ fprintf (stdout, " DevicePathString DevicePathString like as:\n"
>+ " \"PciRoot(0)/Pci(0,0)\"\n"
>+ " start with \" and end with \"\n"
>+ " not support blank in device path string.\n");
>+
>+ fprintf (stdout, " --version Show program's version number and
>exit.\n");
>+ fprintf (stdout, " -h, --help Show this help message and exit.\n");
>+}
>+
>+
>+void print_mem(void const *vp, size_t n)
>+{
>+ unsigned char const *p = vp;
>+ for (size_t i=0; i<n; i++) {
>+ printf("0x%02x ", p[i]);
>+ }
>+}
>+
>+VOID
>+Ascii2UnicodeString (
>+ CHAR8 *String,
>+ CHAR16 *UniString
>+ )
>+/*++
>+
>+Routine Description:
>+
>+ Write ascii string as unicode string format to FILE
>+
>+Arguments:
>+
>+ String - Pointer to string that is written to FILE.
>+ UniString - Pointer to unicode string
>+
>+Returns:
>+
>+ NULL
>+
>+--*/
>+{
>+ while (*String != '\0') {
>+ *(UniString++) = (CHAR16) *(String++);
>+ }
>+ //
>+ // End the UniString with a NULL.
>+ //
>+ *UniString = '\0';
>+}
>+
>+int main(int argc, CHAR8 *argv[])
>+{
>+ CHAR8 * Str;
>+ CHAR16* Str16;
>+ EFI_DEVICE_PATH_PROTOCOL *DevicePath;
>+
>+ if (argc == 1) {
>+ Error (NULL, 0, 1001, "Missing options", "No input options specified.");
>+ Usage ();
>+ return STATUS_ERROR;
>+ }
>+ if ((stricmp (argv[1], "-h") == 0) || (stricmp (argv[1], "--help") == 0)) {
>+ Version ();
>+ Usage ();
>+ return STATUS_SUCCESS;
>+ }
>+
>+ if (stricmp (argv[1], "--version") == 0) {
>+ Version ();
>+ return STATUS_SUCCESS;
>+ }
>+ Str = argv[1];
>+ if (Str == NULL) {
>+ fprintf(stderr, "Invalid option value, Device Path can't be NULL");
>+ return STATUS_ERROR;
>+ }
>+ Str16 = (CHAR16 *)malloc(1024);
>+ if (Str16 == NULL) {
>+ fprintf(stderr, "Resource, memory cannot be allcoated");
>+ return STATUS_ERROR;
>+ }
>+ Ascii2UnicodeString(Str, Str16);
>+ DevicePath = UefiDevicePathLibConvertTextToDevicePath(Str16);
>+ while (!((DevicePath->Type == END_DEVICE_PATH_TYPE) && (DevicePath-
>>SubType == END_ENTIRE_DEVICE_PATH_SUBTYPE)) )
>+ {
>+ print_mem(DevicePath, (DevicePath->Length[0] | DevicePath->Length[1]
><< 8));
>+ DevicePath = (EFI_DEVICE_PATH_PROTOCOL *)((UINT8 *)DevicePath +
>(DevicePath->Length[0] | DevicePath->Length[1] << 8));
>+ }
>+ print_mem(DevicePath, (DevicePath->Length[0] | DevicePath->Length[1]
><< 8));
>+ putchar('\n');
>+ return STATUS_SUCCESS;
>+}
>diff --git a/BaseTools/Source/C/DevicePath/DevicePath.h
>b/BaseTools/Source/C/DevicePath/DevicePath.h
>new file mode 100644
>index 0000000..389c993
>--- /dev/null
>+++ b/BaseTools/Source/C/DevicePath/DevicePath.h
>@@ -0,0 +1,1404 @@
>+/** @file
>+ The device path protocol as defined in UEFI 2.0.
>+
>+ The device path represents a programmatic path to a device,
>+ from a software point of view. The path must persist from boot to boot, so
>+ it can not contain things like PCI bus numbers that change from boot to boot.
>+
>+Copyright (c) 2017, Intel Corporation. All rights reserved.<BR>
>+This program and the accompanying materials are licensed and made
>available under
>+the terms and conditions of the BSD License that accompanies this
>distribution.
>+The full text of the license may be found at
>+http://opensource.org/licenses/bsd-license.php.
>+
>+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+**/
>+
>+#ifndef __EFI_DEVICE_PATH_H__
>+#define __EFI_DEVICE_PATH_H__
>+
>+#include <Guid/PcAnsi.h>
>+#include <IndustryStandard/Acpi3_0.h>
>+
>+///
>+/// Device Path protocol.
>+///
>+#define EFI_DEVICE_PATH_PROTOCOL_GUID \
>+ { \
>+ 0x9576e91, 0x6d3f, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b }
>\
>+ }
>+
>+///
>+/// Device Path guid definition for backward-compatible with EFI1.1.
>+///
>+#define DEVICE_PATH_PROTOCOL EFI_DEVICE_PATH_PROTOCOL_GUID
>+
>+#pragma pack(1)
>+
>+/**
>+ This protocol can be used on any device handle to obtain generic
>path/location
>+ information concerning the physical device or logical device. If the handle
>does
>+ not logically map to a physical device, the handle may not necessarily
>support
>+ the device path protocol. The device path describes the location of the
>device
>+ the handle is for. The size of the Device Path can be determined from the
>structures
>+ that make up the Device Path.
>+**/
>+typedef struct {
>+ UINT8 Type; ///< 0x01 Hardware Device Path.
>+ ///< 0x02 ACPI Device Path.
>+ ///< 0x03 Messaging Device Path.
>+ ///< 0x04 Media Device Path.
>+ ///< 0x05 BIOS Boot Specification Device Path.
>+ ///< 0x7F End of Hardware Device Path.
>+
>+ UINT8 SubType; ///< Varies by Type
>+ ///< 0xFF End Entire Device Path, or
>+ ///< 0x01 End This Instance of a Device Path and start a new
>+ ///< Device Path.
>+
>+ UINT8 Length[2]; ///< Specific Device Path data. Type and Sub-Type define
>+ ///< type of data. Size of data is included in Length.
>+
>+} EFI_DEVICE_PATH_PROTOCOL;
>+
>+///
>+/// Device Path protocol definition for backward-compatible with EFI1.1.
>+///
>+typedef EFI_DEVICE_PATH_PROTOCOL EFI_DEVICE_PATH;
>+
>+///
>+/// Hardware Device Paths.
>+///
>+#define HARDWARE_DEVICE_PATH 0x01
>+
>+///
>+/// PCI Device Path SubType.
>+///
>+#define HW_PCI_DP 0x01
>+
>+///
>+/// PCI Device Path.
>+///
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// PCI Function Number.
>+ ///
>+ UINT8 Function;
>+ ///
>+ /// PCI Device Number.
>+ ///
>+ UINT8 Device;
>+} PCI_DEVICE_PATH;
>+
>+///
>+/// PCCARD Device Path SubType.
>+///
>+#define HW_PCCARD_DP 0x02
>+
>+///
>+/// PCCARD Device Path.
>+///
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// Function Number (0 = First Function).
>+ ///
>+ UINT8 FunctionNumber;
>+} PCCARD_DEVICE_PATH;
>+
>+///
>+/// Memory Mapped Device Path SubType.
>+///
>+#define HW_MEMMAP_DP 0x03
>+
>+///
>+/// Memory Mapped Device Path.
>+///
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// EFI_MEMORY_TYPE
>+ ///
>+ UINT32 MemoryType;
>+ ///
>+ /// Starting Memory Address.
>+ ///
>+ EFI_PHYSICAL_ADDRESS StartingAddress;
>+ ///
>+ /// Ending Memory Address.
>+ ///
>+ EFI_PHYSICAL_ADDRESS EndingAddress;
>+} MEMMAP_DEVICE_PATH;
>+
>+///
>+/// Hardware Vendor Device Path SubType.
>+///
>+#define HW_VENDOR_DP 0x04
>+
>+///
>+/// The Vendor Device Path allows the creation of vendor-defined Device
>Paths. A vendor must
>+/// allocate a Vendor GUID for a Device Path. The Vendor GUID can then be
>used to define the
>+/// contents on the n bytes that follow in the Vendor Device Path node.
>+///
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// Vendor-assigned GUID that defines the data that follows.
>+ ///
>+ EFI_GUID Guid;
>+ ///
>+ /// Vendor-defined variable size data.
>+ ///
>+} VENDOR_DEVICE_PATH;
>+
>+///
>+/// Controller Device Path SubType.
>+///
>+#define HW_CONTROLLER_DP 0x05
>+
>+///
>+/// Controller Device Path.
>+///
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// Controller number.
>+ ///
>+ UINT32 ControllerNumber;
>+} CONTROLLER_DEVICE_PATH;
>+
>+///
>+/// BMC Device Path SubType.
>+///
>+#define HW_BMC_DP 0x06
>+
>+///
>+/// BMC Device Path.
>+///
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// Interface Type.
>+ ///
>+ UINT8 InterfaceType;
>+ ///
>+ /// Base Address.
>+ ///
>+ UINT8 BaseAddress[8];
>+} BMC_DEVICE_PATH;
>+
>+///
>+/// ACPI Device Paths.
>+///
>+#define ACPI_DEVICE_PATH 0x02
>+
>+///
>+/// ACPI Device Path SubType.
>+///
>+#define ACPI_DP 0x01
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// Device's PnP hardware ID stored in a numeric 32-bit
>+ /// compressed EISA-type ID. This value must match the
>+ /// corresponding _HID in the ACPI name space.
>+ ///
>+ UINT32 HID;
>+ ///
>+ /// Unique ID that is required by ACPI if two devices have the
>+ /// same _HID. This value must also match the corresponding
>+ /// _UID/_HID pair in the ACPI name space. Only the 32-bit
>+ /// numeric value type of _UID is supported. Thus, strings must
>+ /// not be used for the _UID in the ACPI name space.
>+ ///
>+ UINT32 UID;
>+} ACPI_HID_DEVICE_PATH;
>+
>+///
>+/// Expanded ACPI Device Path SubType.
>+///
>+#define ACPI_EXTENDED_DP 0x02
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// Device's PnP hardware ID stored in a numeric 32-bit
>+ /// compressed EISA-type ID. This value must match the
>+ /// corresponding _HID in the ACPI name space.
>+ ///
>+ UINT32 HID;
>+ ///
>+ /// Unique ID that is required by ACPI if two devices have the
>+ /// same _HID. This value must also match the corresponding
>+ /// _UID/_HID pair in the ACPI name space.
>+ ///
>+ UINT32 UID;
>+ ///
>+ /// Device's compatible PnP hardware ID stored in a numeric
>+ /// 32-bit compressed EISA-type ID. This value must match at
>+ /// least one of the compatible device IDs returned by the
>+ /// corresponding _CID in the ACPI name space.
>+ ///
>+ UINT32 CID;
>+ ///
>+ /// Optional variable length _HIDSTR.
>+ /// Optional variable length _UIDSTR.
>+ /// Optional variable length _CIDSTR.
>+ ///
>+} ACPI_EXTENDED_HID_DEVICE_PATH;
>+
>+//
>+// EISA ID Macro
>+// EISA ID Definition 32-bits
>+// bits[15:0] - three character compressed ASCII EISA ID.
>+// bits[31:16] - binary number
>+// Compressed ASCII is 5 bits per character 0b00001 = 'A' 0b11010 = 'Z'
>+//
>+#define PNP_EISA_ID_CONST 0x41d0
>+#define EISA_ID(_Name, _Num) ((UINT32)((_Name) | (_Num) << 16))
>+#define EISA_PNP_ID(_PNPId) (EISA_ID(PNP_EISA_ID_CONST, (_PNPId)))
>+#define EFI_PNP_ID(_PNPId) (EISA_ID(PNP_EISA_ID_CONST, (_PNPId)))
>+
>+#define PNP_EISA_ID_MASK 0xffff
>+#define EISA_ID_TO_NUM(_Id) ((_Id) >> 16)
>+
>+///
>+/// ACPI _ADR Device Path SubType.
>+///
>+#define ACPI_ADR_DP 0x03
>+
>+///
>+/// The _ADR device path is used to contain video output device attributes to
>support the Graphics
>+/// Output Protocol. The device path can contain multiple _ADR entries if
>multiple video output
>+/// devices are displaying the same output.
>+///
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// _ADR value. For video output devices the value of this
>+ /// field comes from Table B-2 of the ACPI 3.0 specification. At
>+ /// least one _ADR value is required.
>+ ///
>+ UINT32 ADR;
>+ //
>+ // This device path may optionally contain more than one _ADR entry.
>+ //
>+} ACPI_ADR_DEVICE_PATH;
>+
>+#define ACPI_ADR_DISPLAY_TYPE_OTHER 0
>+#define ACPI_ADR_DISPLAY_TYPE_VGA 1
>+#define ACPI_ADR_DISPLAY_TYPE_TV 2
>+#define ACPI_ADR_DISPLAY_TYPE_EXTERNAL_DIGITAL 3
>+#define ACPI_ADR_DISPLAY_TYPE_INTERNAL_DIGITAL 4
>+
>+#define ACPI_DISPLAY_ADR(_DeviceIdScheme, _HeadId, _NonVgaOutput,
>_BiosCanDetect, _VendorInfo, _Type, _Port, _Index) \
>+ ((UINT32)( ((UINT32)((_DeviceIdScheme) & 0x1) << 31) | \
>+ (((_HeadId) & 0x7) << 18) | \
>+ (((_NonVgaOutput) & 0x1) << 17) | \
>+ (((_BiosCanDetect) & 0x1) << 16) | \
>+ (((_VendorInfo) & 0xf) << 12) | \
>+ (((_Type) & 0xf) << 8) | \
>+ (((_Port) & 0xf) << 4) | \
>+ ((_Index) & 0xf) ))
>+
>+///
>+/// Messaging Device Paths.
>+/// This Device Path is used to describe the connection of devices outside
>the resource domain of the
>+/// system. This Device Path can describe physical messaging information like
>SCSI ID, or abstract
>+/// information like networking protocol IP addresses.
>+///
>+#define MESSAGING_DEVICE_PATH 0x03
>+
>+///
>+/// ATAPI Device Path SubType
>+///
>+#define MSG_ATAPI_DP 0x01
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// Set to zero for primary, or one for secondary.
>+ ///
>+ UINT8 PrimarySecondary;
>+ ///
>+ /// Set to zero for master, or one for slave mode.
>+ ///
>+ UINT8 SlaveMaster;
>+ ///
>+ /// Logical Unit Number.
>+ ///
>+ UINT16 Lun;
>+} ATAPI_DEVICE_PATH;
>+
>+///
>+/// SCSI Device Path SubType.
>+///
>+#define MSG_SCSI_DP 0x02
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// Target ID on the SCSI bus (PUN).
>+ ///
>+ UINT16 Pun;
>+ ///
>+ /// Logical Unit Number (LUN).
>+ ///
>+ UINT16 Lun;
>+} SCSI_DEVICE_PATH;
>+
>+///
>+/// Fibre Channel SubType.
>+///
>+#define MSG_FIBRECHANNEL_DP 0x03
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// Reserved for the future.
>+ ///
>+ UINT32 Reserved;
>+ ///
>+ /// Fibre Channel World Wide Number.
>+ ///
>+ UINT64 WWN;
>+ ///
>+ /// Fibre Channel Logical Unit Number.
>+ ///
>+ UINT64 Lun;
>+} FIBRECHANNEL_DEVICE_PATH;
>+
>+///
>+/// Fibre Channel Ex SubType.
>+///
>+#define MSG_FIBRECHANNELEX_DP 0x15
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// Reserved for the future.
>+ ///
>+ UINT32 Reserved;
>+ ///
>+ /// 8 byte array containing Fibre Channel End Device Port Name.
>+ ///
>+ UINT8 WWN[8];
>+ ///
>+ /// 8 byte array containing Fibre Channel Logical Unit Number.
>+ ///
>+ UINT8 Lun[8];
>+} FIBRECHANNELEX_DEVICE_PATH;
>+
>+///
>+/// 1394 Device Path SubType
>+///
>+#define MSG_1394_DP 0x04
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// Reserved for the future.
>+ ///
>+ UINT32 Reserved;
>+ ///
>+ /// 1394 Global Unique ID (GUID).
>+ ///
>+ UINT64 Guid;
>+} F1394_DEVICE_PATH;
>+
>+///
>+/// USB Device Path SubType.
>+///
>+#define MSG_USB_DP 0x05
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// USB Parent Port Number.
>+ ///
>+ UINT8 ParentPortNumber;
>+ ///
>+ /// USB Interface Number.
>+ ///
>+ UINT8 InterfaceNumber;
>+} USB_DEVICE_PATH;
>+
>+///
>+/// USB Class Device Path SubType.
>+///
>+#define MSG_USB_CLASS_DP 0x0f
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// Vendor ID assigned by USB-IF. A value of 0xFFFF will
>+ /// match any Vendor ID.
>+ ///
>+ UINT16 VendorId;
>+ ///
>+ /// Product ID assigned by USB-IF. A value of 0xFFFF will
>+ /// match any Product ID.
>+ ///
>+ UINT16 ProductId;
>+ ///
>+ /// The class code assigned by the USB-IF. A value of 0xFF
>+ /// will match any class code.
>+ ///
>+ UINT8 DeviceClass;
>+ ///
>+ /// The subclass code assigned by the USB-IF. A value of
>+ /// 0xFF will match any subclass code.
>+ ///
>+ UINT8 DeviceSubClass;
>+ ///
>+ /// The protocol code assigned by the USB-IF. A value of
>+ /// 0xFF will match any protocol code.
>+ ///
>+ UINT8 DeviceProtocol;
>+} USB_CLASS_DEVICE_PATH;
>+
>+///
>+/// USB WWID Device Path SubType.
>+///
>+#define MSG_USB_WWID_DP 0x10
>+
>+///
>+/// This device path describes a USB device using its serial number.
>+///
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// USB interface number.
>+ ///
>+ UINT16 InterfaceNumber;
>+ ///
>+ /// USB vendor id of the device.
>+ ///
>+ UINT16 VendorId;
>+ ///
>+ /// USB product id of the device.
>+ ///
>+ UINT16 ProductId;
>+ ///
>+ /// Last 64-or-fewer UTF-16 characters of the USB
>+ /// serial number. The length of the string is
>+ /// determined by the Length field less the offset of the
>+ /// Serial Number field (10)
>+ ///
>+ /// CHAR16 SerialNumber[...];
>+} USB_WWID_DEVICE_PATH;
>+
>+///
>+/// Device Logical Unit SubType.
>+///
>+#define MSG_DEVICE_LOGICAL_UNIT_DP 0x11
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// Logical Unit Number for the interface.
>+ ///
>+ UINT8 Lun;
>+} DEVICE_LOGICAL_UNIT_DEVICE_PATH;
>+
>+///
>+/// SATA Device Path SubType.
>+///
>+#define MSG_SATA_DP 0x12
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// The HBA port number that facilitates the connection to the
>+ /// device or a port multiplier. The value 0xFFFF is reserved.
>+ ///
>+ UINT16 HBAPortNumber;
>+ ///
>+ /// The Port multiplier port number that facilitates the connection
>+ /// to the device. Must be set to 0xFFFF if the device is directly
>+ /// connected to the HBA.
>+ ///
>+ UINT16 PortMultiplierPortNumber;
>+ ///
>+ /// Logical Unit Number.
>+ ///
>+ UINT16 Lun;
>+} SATA_DEVICE_PATH;
>+
>+///
>+/// Flag for if the device is directly connected to the HBA.
>+///
>+#define SATA_HBA_DIRECT_CONNECT_FLAG 0x8000
>+
>+///
>+/// I2O Device Path SubType.
>+///
>+#define MSG_I2O_DP 0x06
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// Target ID (TID) for a device.
>+ ///
>+ UINT32 Tid;
>+} I2O_DEVICE_PATH;
>+
>+///
>+/// MAC Address Device Path SubType.
>+///
>+#define MSG_MAC_ADDR_DP 0x0b
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// The MAC address for a network interface padded with 0s.
>+ ///
>+ EFI_MAC_ADDRESS MacAddress;
>+ ///
>+ /// Network interface type(i.e. 802.3, FDDI).
>+ ///
>+ UINT8 IfType;
>+} MAC_ADDR_DEVICE_PATH;
>+
>+///
>+/// IPv4 Device Path SubType
>+///
>+#define MSG_IPv4_DP 0x0c
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// The local IPv4 address.
>+ ///
>+ EFI_IPv4_ADDRESS LocalIpAddress;
>+ ///
>+ /// The remote IPv4 address.
>+ ///
>+ EFI_IPv4_ADDRESS RemoteIpAddress;
>+ ///
>+ /// The local port number.
>+ ///
>+ UINT16 LocalPort;
>+ ///
>+ /// The remote port number.
>+ ///
>+ UINT16 RemotePort;
>+ ///
>+ /// The network protocol(i.e. UDP, TCP).
>+ ///
>+ UINT16 Protocol;
>+ ///
>+ /// 0x00 - The Source IP Address was assigned though DHCP.
>+ /// 0x01 - The Source IP Address is statically bound.
>+ ///
>+ BOOLEAN StaticIpAddress;
>+ ///
>+ /// The gateway IP address
>+ ///
>+ EFI_IPv4_ADDRESS GatewayIpAddress;
>+ ///
>+ /// The subnet mask
>+ ///
>+ EFI_IPv4_ADDRESS SubnetMask;
>+} IPv4_DEVICE_PATH;
>+
>+///
>+/// IPv6 Device Path SubType.
>+///
>+#define MSG_IPv6_DP 0x0d
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// The local IPv6 address.
>+ ///
>+ EFI_IPv6_ADDRESS LocalIpAddress;
>+ ///
>+ /// The remote IPv6 address.
>+ ///
>+ EFI_IPv6_ADDRESS RemoteIpAddress;
>+ ///
>+ /// The local port number.
>+ ///
>+ UINT16 LocalPort;
>+ ///
>+ /// The remote port number.
>+ ///
>+ UINT16 RemotePort;
>+ ///
>+ /// The network protocol(i.e. UDP, TCP).
>+ ///
>+ UINT16 Protocol;
>+ ///
>+ /// 0x00 - The Local IP Address was manually configured.
>+ /// 0x01 - The Local IP Address is assigned through IPv6
>+ /// stateless auto-configuration.
>+ /// 0x02 - The Local IP Address is assigned through IPv6
>+ /// stateful configuration.
>+ ///
>+ UINT8 IpAddressOrigin;
>+ ///
>+ /// The prefix length
>+ ///
>+ UINT8 PrefixLength;
>+ ///
>+ /// The gateway IP address
>+ ///
>+ EFI_IPv6_ADDRESS GatewayIpAddress;
>+} IPv6_DEVICE_PATH;
>+
>+///
>+/// InfiniBand Device Path SubType.
>+///
>+#define MSG_INFINIBAND_DP 0x09
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// Flags to help identify/manage InfiniBand device path elements:
>+ /// Bit 0 - IOC/Service (0b = IOC, 1b = Service).
>+ /// Bit 1 - Extend Boot Environment.
>+ /// Bit 2 - Console Protocol.
>+ /// Bit 3 - Storage Protocol.
>+ /// Bit 4 - Network Protocol.
>+ /// All other bits are reserved.
>+ ///
>+ UINT32 ResourceFlags;
>+ ///
>+ /// 128-bit Global Identifier for remote fabric port.
>+ ///
>+ UINT8 PortGid[16];
>+ ///
>+ /// 64-bit unique identifier to remote IOC or server process.
>+ /// Interpretation of field specified by Resource Flags (bit 0).
>+ ///
>+ UINT64 ServiceId;
>+ ///
>+ /// 64-bit persistent ID of remote IOC port.
>+ ///
>+ UINT64 TargetPortId;
>+ ///
>+ /// 64-bit persistent ID of remote device.
>+ ///
>+ UINT64 DeviceId;
>+} INFINIBAND_DEVICE_PATH;
>+
>+#define INFINIBAND_RESOURCE_FLAG_IOC_SERVICE 0x01
>+#define INFINIBAND_RESOURCE_FLAG_EXTENDED_BOOT_ENVIRONMENT
>0x02
>+#define INFINIBAND_RESOURCE_FLAG_CONSOLE_PROTOCOL 0x04
>+#define INFINIBAND_RESOURCE_FLAG_STORAGE_PROTOCOL 0x08
>+#define INFINIBAND_RESOURCE_FLAG_NETWORK_PROTOCOL 0x10
>+
>+///
>+/// UART Device Path SubType.
>+///
>+#define MSG_UART_DP 0x0e
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// Reserved.
>+ ///
>+ UINT32 Reserved;
>+ ///
>+ /// The baud rate setting for the UART style device. A value of 0
>+ /// means that the device's default baud rate will be used.
>+ ///
>+ UINT64 BaudRate;
>+ ///
>+ /// The number of data bits for the UART style device. A value
>+ /// of 0 means that the device's default number of data bits will be used.
>+ ///
>+ UINT8 DataBits;
>+ ///
>+ /// The parity setting for the UART style device.
>+ /// Parity 0x00 - Default Parity.
>+ /// Parity 0x01 - No Parity.
>+ /// Parity 0x02 - Even Parity.
>+ /// Parity 0x03 - Odd Parity.
>+ /// Parity 0x04 - Mark Parity.
>+ /// Parity 0x05 - Space Parity.
>+ ///
>+ UINT8 Parity;
>+ ///
>+ /// The number of stop bits for the UART style device.
>+ /// Stop Bits 0x00 - Default Stop Bits.
>+ /// Stop Bits 0x01 - 1 Stop Bit.
>+ /// Stop Bits 0x02 - 1.5 Stop Bits.
>+ /// Stop Bits 0x03 - 2 Stop Bits.
>+ ///
>+ UINT8 StopBits;
>+} UART_DEVICE_PATH;
>+
>+//
>+// Use VENDOR_DEVICE_PATH struct
>+//
>+#define MSG_VENDOR_DP 0x0a
>+typedef VENDOR_DEVICE_PATH VENDOR_DEFINED_DEVICE_PATH;
>+
>+#define DEVICE_PATH_MESSAGING_PC_ANSI EFI_PC_ANSI_GUID
>+#define DEVICE_PATH_MESSAGING_VT_100 EFI_VT_100_GUID
>+#define DEVICE_PATH_MESSAGING_VT_100_PLUS EFI_VT_100_PLUS_GUID
>+#define DEVICE_PATH_MESSAGING_VT_UTF8 EFI_VT_UTF8_GUID
>+
>+///
>+/// A new device path node is defined to declare flow control characteristics.
>+/// UART Flow Control Messaging Device Path
>+///
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// DEVICE_PATH_MESSAGING_UART_FLOW_CONTROL GUID.
>+ ///
>+ EFI_GUID Guid;
>+ ///
>+ /// Bitmap of supported flow control types.
>+ /// Bit 0 set indicates hardware flow control.
>+ /// Bit 1 set indicates Xon/Xoff flow control.
>+ /// All other bits are reserved and are clear.
>+ ///
>+ UINT32 FlowControlMap;
>+} UART_FLOW_CONTROL_DEVICE_PATH;
>+
>+#define UART_FLOW_CONTROL_HARDWARE 0x00000001
>+#define UART_FLOW_CONTROL_XON_XOFF 0x00000010
>+
>+#define DEVICE_PATH_MESSAGING_SAS EFI_SAS_DEVICE_PATH_GUID
>+///
>+/// Serial Attached SCSI (SAS) Device Path.
>+///
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// DEVICE_PATH_MESSAGING_SAS GUID.
>+ ///
>+ EFI_GUID Guid;
>+ ///
>+ /// Reserved for future use.
>+ ///
>+ UINT32 Reserved;
>+ ///
>+ /// SAS Address for Serial Attached SCSI Target.
>+ ///
>+ UINT64 SasAddress;
>+ ///
>+ /// SAS Logical Unit Number.
>+ ///
>+ UINT64 Lun;
>+ ///
>+ /// More Information about the device and its interconnect.
>+ ///
>+ UINT16 DeviceTopology;
>+ ///
>+ /// Relative Target Port (RTP).
>+ ///
>+ UINT16 RelativeTargetPort;
>+} SAS_DEVICE_PATH;
>+
>+///
>+/// Serial Attached SCSI (SAS) Ex Device Path SubType
>+///
>+#define MSG_SASEX_DP 0x16
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// 8-byte array of the SAS Address for Serial Attached SCSI Target Port.
>+ ///
>+ UINT8 SasAddress[8];
>+ ///
>+ /// 8-byte array of the SAS Logical Unit Number.
>+ ///
>+ UINT8 Lun[8];
>+ ///
>+ /// More Information about the device and its interconnect.
>+ ///
>+ UINT16 DeviceTopology;
>+ ///
>+ /// Relative Target Port (RTP).
>+ ///
>+ UINT16 RelativeTargetPort;
>+} SASEX_DEVICE_PATH;
>+
>+///
>+/// NvmExpress Namespace Device Path SubType.
>+///
>+#define MSG_NVME_NAMESPACE_DP 0x17
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ UINT32 NamespaceId;
>+ UINT64 NamespaceUuid;
>+} NVME_NAMESPACE_DEVICE_PATH;
>+
>+///
>+/// DNS Device Path SubType
>+///
>+#define MSG_DNS_DP 0x1F
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// Indicates the DNS server address is IPv4 or IPv6 address.
>+ ///
>+ UINT8 IsIPv6;
>+ ///
>+ /// Instance of the DNS server address.
>+ ///
>+ EFI_IP_ADDRESS DnsServerIp[1024];
>+} DNS_DEVICE_PATH;
>+
>+///
>+/// Uniform Resource Identifiers (URI) Device Path SubType
>+///
>+#define MSG_URI_DP 0x18
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// Instance of the URI pursuant to RFC 3986.
>+ ///
>+ CHAR8 Uri[1024];
>+} URI_DEVICE_PATH;
>+
>+///
>+/// Universal Flash Storage (UFS) Device Path SubType.
>+///
>+#define MSG_UFS_DP 0x19
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// Target ID on the UFS bus (PUN).
>+ ///
>+ UINT8 Pun;
>+ ///
>+ /// Logical Unit Number (LUN).
>+ ///
>+ UINT8 Lun;
>+} UFS_DEVICE_PATH;
>+
>+///
>+/// SD (Secure Digital) Device Path SubType.
>+///
>+#define MSG_SD_DP 0x1A
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ UINT8 SlotNumber;
>+} SD_DEVICE_PATH;
>+
>+///
>+/// EMMC (Embedded MMC) Device Path SubType.
>+///
>+#define MSG_EMMC_DP 0x1D
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ UINT8 SlotNumber;
>+} EMMC_DEVICE_PATH;
>+
>+///
>+/// iSCSI Device Path SubType
>+///
>+#define MSG_ISCSI_DP 0x13
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// Network Protocol (0 = TCP, 1+ = reserved).
>+ ///
>+ UINT16 NetworkProtocol;
>+ ///
>+ /// iSCSI Login Options.
>+ ///
>+ UINT16 LoginOption;
>+ ///
>+ /// iSCSI Logical Unit Number.
>+ ///
>+ UINT64 Lun;
>+ ///
>+ /// iSCSI Target Portal group tag the initiator intends
>+ /// to establish a session with.
>+ ///
>+ UINT16 TargetPortalGroupTag;
>+ ///
>+ /// iSCSI NodeTarget Name. The length of the name
>+ /// is determined by subtracting the offset of this field from Length.
>+ ///
>+ /// CHAR8 iSCSI Target Name.
>+} ISCSI_DEVICE_PATH;
>+
>+#define ISCSI_LOGIN_OPTION_NO_HEADER_DIGEST 0x0000
>+#define ISCSI_LOGIN_OPTION_HEADER_DIGEST_USING_CRC32C 0x0002
>+#define ISCSI_LOGIN_OPTION_NO_DATA_DIGEST 0x0000
>+#define ISCSI_LOGIN_OPTION_DATA_DIGEST_USING_CRC32C 0x0008
>+#define ISCSI_LOGIN_OPTION_AUTHMETHOD_CHAP 0x0000
>+#define ISCSI_LOGIN_OPTION_AUTHMETHOD_NON 0x1000
>+#define ISCSI_LOGIN_OPTION_CHAP_BI 0x0000
>+#define ISCSI_LOGIN_OPTION_CHAP_UNI 0x2000
>+
>+///
>+/// VLAN Device Path SubType.
>+///
>+#define MSG_VLAN_DP 0x14
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// VLAN identifier (0-4094).
>+ ///
>+ UINT16 VlanId;
>+} VLAN_DEVICE_PATH;
>+
>+///
>+/// BLUETOOTH_ADDRESS
>+///
>+typedef struct {
>+ ///
>+ /// 48bit Bluetooth device address.
>+ ///
>+ UINT8 Address[6];
>+} BLUETOOTH_ADDRESS;
>+
>+///
>+/// Bluetooth Device Path SubType.
>+///
>+#define MSG_BLUETOOTH_DP 0x1b
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// 48bit Bluetooth device address.
>+ ///
>+ BLUETOOTH_ADDRESS BD_ADDR;
>+} BLUETOOTH_DEVICE_PATH;
>+
>+///
>+/// Wi-Fi Device Path SubType.
>+///
>+#define MSG_WIFI_DP 0x1C
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// Service set identifier. A 32-byte octets string.
>+ ///
>+ UINT8 SSId[32];
>+} WIFI_DEVICE_PATH;
>+
>+///
>+/// BLUETOOTH_LE_ADDRESS
>+///
>+typedef struct {
>+ ///
>+ /// 48-bit Bluetooth device address
>+ ///
>+ UINT8 Address[6];
>+ ///
>+ /// 0x00 - Public Device Address
>+ /// 0x01 - Random Device Address
>+ ///
>+ UINT8 Type;
>+} BLUETOOTH_LE_ADDRESS;
>+
>+///
>+/// Bluetooth LE Device Path SubType.
>+///
>+#define MSG_BLUETOOTH_LE_DP 0x1E
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ BLUETOOTH_LE_ADDRESS Address;
>+} BLUETOOTH_LE_DEVICE_PATH;
>+
>+//
>+// Media Device Path
>+//
>+#define MEDIA_DEVICE_PATH 0x04
>+
>+///
>+/// Hard Drive Media Device Path SubType.
>+///
>+#define MEDIA_HARDDRIVE_DP 0x01
>+
>+///
>+/// The Hard Drive Media Device Path is used to represent a partition on a
>hard drive.
>+///
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// Describes the entry in a partition table, starting with entry 1.
>+ /// Partition number zero represents the entire device. Valid
>+ /// partition numbers for a MBR partition are [1, 4]. Valid
>+ /// partition numbers for a GPT partition are [1, NumberOfPartitionEntries].
>+ ///
>+ UINT32 PartitionNumber;
>+ ///
>+ /// Starting LBA of the partition on the hard drive.
>+ ///
>+ UINT64 PartitionStart;
>+ ///
>+ /// Size of the partition in units of Logical Blocks.
>+ ///
>+ UINT64 PartitionSize;
>+ ///
>+ /// Signature unique to this partition:
>+ /// If SignatureType is 0, this field has to be initialized with 16 zeros.
>+ /// If SignatureType is 1, the MBR signature is stored in the first 4 bytes of
>this field.
>+ /// The other 12 bytes are initialized with zeros.
>+ /// If SignatureType is 2, this field contains a 16 byte signature.
>+ ///
>+ UINT8 Signature[16];
>+ ///
>+ /// Partition Format: (Unused values reserved).
>+ /// 0x01 - PC-AT compatible legacy MBR.
>+ /// 0x02 - GUID Partition Table.
>+ ///
>+ UINT8 MBRType;
>+ ///
>+ /// Type of Disk Signature: (Unused values reserved).
>+ /// 0x00 - No Disk Signature.
>+ /// 0x01 - 32-bit signature from address 0x1b8 of the type 0x01 MBR.
>+ /// 0x02 - GUID signature.
>+ ///
>+ UINT8 SignatureType;
>+} HARDDRIVE_DEVICE_PATH;
>+
>+#define MBR_TYPE_PCAT 0x01
>+#define MBR_TYPE_EFI_PARTITION_TABLE_HEADER 0x02
>+
>+#define NO_DISK_SIGNATURE 0x00
>+#define SIGNATURE_TYPE_MBR 0x01
>+#define SIGNATURE_TYPE_GUID 0x02
>+
>+///
>+/// CD-ROM Media Device Path SubType.
>+///
>+#define MEDIA_CDROM_DP 0x02
>+
>+///
>+/// The CD-ROM Media Device Path is used to define a system partition that
>exists on a CD-ROM.
>+///
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// Boot Entry number from the Boot Catalog. The Initial/Default entry is
>defined as zero.
>+ ///
>+ UINT32 BootEntry;
>+ ///
>+ /// Starting RBA of the partition on the medium. CD-ROMs use Relative
>logical Block Addressing.
>+ ///
>+ UINT64 PartitionStart;
>+ ///
>+ /// Size of the partition in units of Blocks, also called Sectors.
>+ ///
>+ UINT64 PartitionSize;
>+} CDROM_DEVICE_PATH;
>+
>+//
>+// Use VENDOR_DEVICE_PATH struct
>+//
>+#define MEDIA_VENDOR_DP 0x03 ///< Media vendor device path
>subtype.
>+
>+///
>+/// File Path Media Device Path SubType
>+///
>+#define MEDIA_FILEPATH_DP 0x04
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// A NULL-terminated Path string including directory and file names.
>+ ///
>+ CHAR16 PathName[1];
>+} FILEPATH_DEVICE_PATH;
>+
>+#define SIZE_OF_FILEPATH_DEVICE_PATH
>OFFSET_OF(FILEPATH_DEVICE_PATH,PathName)
>+
>+///
>+/// Media Protocol Device Path SubType.
>+///
>+#define MEDIA_PROTOCOL_DP 0x05
>+
>+///
>+/// The Media Protocol Device Path is used to denote the protocol that is
>being
>+/// used in a device path at the location of the path specified.
>+/// Many protocols are inherent to the style of device path.
>+///
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// The ID of the protocol.
>+ ///
>+ EFI_GUID Protocol;
>+} MEDIA_PROTOCOL_DEVICE_PATH;
>+
>+///
>+/// PIWG Firmware File SubType.
>+///
>+#define MEDIA_PIWG_FW_FILE_DP 0x06
>+
>+///
>+/// This device path is used by systems implementing the UEFI PI
>Specification 1.0 to describe a firmware file.
>+///
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// Firmware file name
>+ ///
>+ EFI_GUID FvFileName;
>+} MEDIA_FW_VOL_FILEPATH_DEVICE_PATH;
>+
>+///
>+/// PIWG Firmware Volume Device Path SubType.
>+///
>+#define MEDIA_PIWG_FW_VOL_DP 0x07
>+
>+///
>+/// This device path is used by systems implementing the UEFI PI
>Specification 1.0 to describe a firmware volume.
>+///
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// Firmware volume name.
>+ ///
>+ EFI_GUID FvName;
>+} MEDIA_FW_VOL_DEVICE_PATH;
>+
>+///
>+/// Media relative offset range device path.
>+///
>+#define MEDIA_RELATIVE_OFFSET_RANGE_DP 0x08
>+
>+///
>+/// Used to describe the offset range of media relative.
>+///
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ UINT32 Reserved;
>+ UINT64 StartingOffset;
>+ UINT64 EndingOffset;
>+} MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH;
>+
>+///
>+/// This GUID defines a RAM Disk supporting a raw disk format in volatile
>memory.
>+///
>+#define EFI_VIRTUAL_DISK_GUID
>EFI_ACPI_6_0_NFIT_GUID_RAM_DISK_SUPPORTING_VIRTUAL_DISK_REGIO
>N_VOLATILE
>+
>+extern EFI_GUID gEfiVirtualDiskGuid;
>+
>+///
>+/// This GUID defines a RAM Disk supporting an ISO image in volatile memory.
>+///
>+#define EFI_VIRTUAL_CD_GUID
>EFI_ACPI_6_0_NFIT_GUID_RAM_DISK_SUPPORTING_VIRTUAL_CD_REGION
>_VOLATILE
>+
>+extern EFI_GUID gEfiVirtualCdGuid;
>+
>+///
>+/// This GUID defines a RAM Disk supporting a raw disk format in persistent
>memory.
>+///
>+#define EFI_PERSISTENT_VIRTUAL_DISK_GUID
>EFI_ACPI_6_0_NFIT_GUID_RAM_DISK_SUPPORTING_VIRTUAL_DISK_REGIO
>N_PERSISTENT
>+
>+extern EFI_GUID gEfiPersistentVirtualDiskGuid;
>+
>+///
>+/// This GUID defines a RAM Disk supporting an ISO image in persistent
>memory.
>+///
>+#define EFI_PERSISTENT_VIRTUAL_CD_GUID
>EFI_ACPI_6_0_NFIT_GUID_RAM_DISK_SUPPORTING_VIRTUAL_CD_REGION
>_PERSISTENT
>+
>+extern EFI_GUID gEfiPersistentVirtualCdGuid;
>+
>+///
>+/// Media ram disk device path.
>+///
>+#define MEDIA_RAM_DISK_DP 0x09
>+
>+///
>+/// Used to describe the ram disk device path.
>+///
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// Starting Memory Address.
>+ ///
>+ UINT32 StartingAddr[2];
>+ ///
>+ /// Ending Memory Address.
>+ ///
>+ UINT32 EndingAddr[2];
>+ ///
>+ /// GUID that defines the type of the RAM Disk.
>+ ///
>+ EFI_GUID TypeGuid;
>+ ///
>+ /// RAM Diskinstance number, if supported. The default value is zero.
>+ ///
>+ UINT16 Instance;
>+} MEDIA_RAM_DISK_DEVICE_PATH;
>+
>+///
>+/// BIOS Boot Specification Device Path.
>+///
>+#define BBS_DEVICE_PATH 0x05
>+
>+///
>+/// BIOS Boot Specification Device Path SubType.
>+///
>+#define BBS_BBS_DP 0x01
>+
>+///
>+/// This Device Path is used to describe the booting of non-EFI-aware
>operating systems.
>+///
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ ///
>+ /// Device Type as defined by the BIOS Boot Specification.
>+ ///
>+ UINT16 DeviceType;
>+ ///
>+ /// Status Flags as defined by the BIOS Boot Specification.
>+ ///
>+ UINT16 StatusFlag;
>+ ///
>+ /// Null-terminated ASCII string that describes the boot device to a user.
>+ ///
>+ CHAR8 String[1];
>+} BBS_BBS_DEVICE_PATH;
>+
>+//
>+// DeviceType definitions - from BBS specification
>+//
>+#define BBS_TYPE_FLOPPY 0x01
>+#define BBS_TYPE_HARDDRIVE 0x02
>+#define BBS_TYPE_CDROM 0x03
>+#define BBS_TYPE_PCMCIA 0x04
>+#define BBS_TYPE_USB 0x05
>+#define BBS_TYPE_EMBEDDED_NETWORK 0x06
>+#define BBS_TYPE_BEV 0x80
>+#define BBS_TYPE_UNKNOWN 0xFF
>+
>+
>+///
>+/// Union of all possible Device Paths and pointers to Device Paths.
>+///
>+typedef union {
>+ EFI_DEVICE_PATH_PROTOCOL DevPath;
>+ PCI_DEVICE_PATH Pci;
>+ PCCARD_DEVICE_PATH PcCard;
>+ MEMMAP_DEVICE_PATH MemMap;
>+ VENDOR_DEVICE_PATH Vendor;
>+
>+ CONTROLLER_DEVICE_PATH Controller;
>+ BMC_DEVICE_PATH Bmc;
>+ ACPI_HID_DEVICE_PATH Acpi;
>+ ACPI_EXTENDED_HID_DEVICE_PATH ExtendedAcpi;
>+ ACPI_ADR_DEVICE_PATH AcpiAdr;
>+
>+ ATAPI_DEVICE_PATH Atapi;
>+ SCSI_DEVICE_PATH Scsi;
>+ ISCSI_DEVICE_PATH Iscsi;
>+ FIBRECHANNEL_DEVICE_PATH FibreChannel;
>+ FIBRECHANNELEX_DEVICE_PATH FibreChannelEx;
>+
>+ F1394_DEVICE_PATH F1394;
>+ USB_DEVICE_PATH Usb;
>+ SATA_DEVICE_PATH Sata;
>+ USB_CLASS_DEVICE_PATH UsbClass;
>+ USB_WWID_DEVICE_PATH UsbWwid;
>+ DEVICE_LOGICAL_UNIT_DEVICE_PATH LogicUnit;
>+ I2O_DEVICE_PATH I2O;
>+ MAC_ADDR_DEVICE_PATH MacAddr;
>+ IPv4_DEVICE_PATH Ipv4;
>+ IPv6_DEVICE_PATH Ipv6;
>+ VLAN_DEVICE_PATH Vlan;
>+ INFINIBAND_DEVICE_PATH InfiniBand;
>+ UART_DEVICE_PATH Uart;
>+ UART_FLOW_CONTROL_DEVICE_PATH UartFlowControl;
>+ SAS_DEVICE_PATH Sas;
>+ SASEX_DEVICE_PATH SasEx;
>+ NVME_NAMESPACE_DEVICE_PATH NvmeNamespace;
>+ DNS_DEVICE_PATH Dns;
>+ URI_DEVICE_PATH Uri;
>+ BLUETOOTH_DEVICE_PATH Bluetooth;
>+ WIFI_DEVICE_PATH WiFi;
>+ UFS_DEVICE_PATH Ufs;
>+ SD_DEVICE_PATH Sd;
>+ EMMC_DEVICE_PATH Emmc;
>+ HARDDRIVE_DEVICE_PATH HardDrive;
>+ CDROM_DEVICE_PATH CD;
>+
>+ FILEPATH_DEVICE_PATH FilePath;
>+ MEDIA_PROTOCOL_DEVICE_PATH MediaProtocol;
>+
>+ MEDIA_FW_VOL_DEVICE_PATH FirmwareVolume;
>+ MEDIA_FW_VOL_FILEPATH_DEVICE_PATH FirmwareFile;
>+ MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH Offset;
>+ MEDIA_RAM_DISK_DEVICE_PATH RamDisk;
>+ BBS_BBS_DEVICE_PATH Bbs;
>+} EFI_DEV_PATH;
>+
>+
>+
>+typedef union {
>+ EFI_DEVICE_PATH_PROTOCOL *DevPath;
>+ PCI_DEVICE_PATH *Pci;
>+ PCCARD_DEVICE_PATH *PcCard;
>+ MEMMAP_DEVICE_PATH *MemMap;
>+ VENDOR_DEVICE_PATH *Vendor;
>+
>+ CONTROLLER_DEVICE_PATH *Controller;
>+ BMC_DEVICE_PATH *Bmc;
>+ ACPI_HID_DEVICE_PATH *Acpi;
>+ ACPI_EXTENDED_HID_DEVICE_PATH *ExtendedAcpi;
>+ ACPI_ADR_DEVICE_PATH *AcpiAdr;
>+
>+ ATAPI_DEVICE_PATH *Atapi;
>+ SCSI_DEVICE_PATH *Scsi;
>+ ISCSI_DEVICE_PATH *Iscsi;
>+ FIBRECHANNEL_DEVICE_PATH *FibreChannel;
>+ FIBRECHANNELEX_DEVICE_PATH *FibreChannelEx;
>+
>+ F1394_DEVICE_PATH *F1394;
>+ USB_DEVICE_PATH *Usb;
>+ SATA_DEVICE_PATH *Sata;
>+ USB_CLASS_DEVICE_PATH *UsbClass;
>+ USB_WWID_DEVICE_PATH *UsbWwid;
>+ DEVICE_LOGICAL_UNIT_DEVICE_PATH *LogicUnit;
>+ I2O_DEVICE_PATH *I2O;
>+ MAC_ADDR_DEVICE_PATH *MacAddr;
>+ IPv4_DEVICE_PATH *Ipv4;
>+ IPv6_DEVICE_PATH *Ipv6;
>+ VLAN_DEVICE_PATH *Vlan;
>+ INFINIBAND_DEVICE_PATH *InfiniBand;
>+ UART_DEVICE_PATH *Uart;
>+ UART_FLOW_CONTROL_DEVICE_PATH *UartFlowControl;
>+ SAS_DEVICE_PATH *Sas;
>+ SASEX_DEVICE_PATH *SasEx;
>+ NVME_NAMESPACE_DEVICE_PATH *NvmeNamespace;
>+ DNS_DEVICE_PATH *Dns;
>+ URI_DEVICE_PATH *Uri;
>+ BLUETOOTH_DEVICE_PATH *Bluetooth;
>+ WIFI_DEVICE_PATH *WiFi;
>+ UFS_DEVICE_PATH *Ufs;
>+ SD_DEVICE_PATH *Sd;
>+ EMMC_DEVICE_PATH *Emmc;
>+ HARDDRIVE_DEVICE_PATH *HardDrive;
>+ CDROM_DEVICE_PATH *CD;
>+
>+ FILEPATH_DEVICE_PATH *FilePath;
>+ MEDIA_PROTOCOL_DEVICE_PATH *MediaProtocol;
>+
>+ MEDIA_FW_VOL_DEVICE_PATH *FirmwareVolume;
>+ MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *FirmwareFile;
>+ MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH *Offset;
>+ MEDIA_RAM_DISK_DEVICE_PATH *RamDisk;
>+ BBS_BBS_DEVICE_PATH *Bbs;
>+ UINT8 *Raw;
>+} EFI_DEV_PATH_PTR;
>+
>+#define EFI_DEBUGPORT_PROTOCOL_GUID \
>+ { \
>+ 0xEBA4E8D2, 0x3858, 0x41EC, {0xA2, 0x81, 0x26, 0x47, 0xBA, 0x96, 0x60,
>0xD0 } \
>+ }
>+//
>+// DEBUGPORT variable definitions...
>+//
>+#define EFI_DEBUGPORT_VARIABLE_NAME L"DEBUGPORT"
>+#define EFI_DEBUGPORT_VARIABLE_GUID
>EFI_DEBUGPORT_PROTOCOL_GUID
>+extern EFI_GUID gEfiDebugPortVariableGuid;
>+
>+//
>+// DebugPort device path definitions...
>+//
>+#define DEVICE_PATH_MESSAGING_DEBUGPORT
>EFI_DEBUGPORT_PROTOCOL_GUID
>+extern EFI_GUID gEfiDebugPortDevicePathGuid;
>+
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ EFI_GUID Guid;
>+} DEBUGPORT_DEVICE_PATH;
>+
>+#pragma pack()
>+
>+#define END_DEVICE_PATH_TYPE 0x7f
>+#define END_ENTIRE_DEVICE_PATH_SUBTYPE 0xFF
>+#define END_INSTANCE_DEVICE_PATH_SUBTYPE 0x01
>+
>+extern EFI_GUID gEfiDevicePathProtocolGuid;
>+
>+#endif
>diff --git a/BaseTools/Source/C/DevicePath/DevicePathFromText.c
>b/BaseTools/Source/C/DevicePath/DevicePathFromText.c
>new file mode 100644
>index 0000000..fb5b09b
>--- /dev/null
>+++ b/BaseTools/Source/C/DevicePath/DevicePathFromText.c
>@@ -0,0 +1,3503 @@
>+/** @file
>+ DevicePathFromText protocol as defined in the UEFI 2.0 specification.
>+
>+Copyright (c) 2017, Intel Corporation. All rights reserved.<BR>
>+This program and the accompanying materials
>+are licensed and made available under the terms and conditions of the BSD
>License
>+which accompanies this distribution. The full text of the license may be
>found at
>+http://opensource.org/licenses/bsd-license.php
>+
>+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+**/
>+
>+#include "UefiDevicePathLib.h"
>+
>+/**
>+
>+ Duplicates a string.
>+
>+ @param Src Source string.
>+
>+ @return The duplicated string.
>+
>+**/
>+CHAR16 *
>+UefiDevicePathLibStrDuplicate (
>+ CONST CHAR16 *Src
>+ )
>+{
>+ return AllocateCopyPool (StrSize (Src), Src);
>+}
>+
>+/**
>+
>+ Get parameter in a pair of parentheses follow the given node name.
>+ For example, given the "Pci(0,1)" and NodeName "Pci", it returns "0,1".
>+
>+ @param Str Device Path Text.
>+ @param NodeName Name of the node.
>+
>+ @return Parameter text for the node.
>+
>+**/
>+CHAR16 *
>+GetParamByNodeName (
>+ CHAR16 *Str,
>+ CHAR16 *NodeName
>+ )
>+{
>+ CHAR16 *ParamStr;
>+ CHAR16 *StrPointer;
>+ UINTN NodeNameLength;
>+ UINTN ParameterLength;
>+
>+ //
>+ // Check whether the node name matchs
>+ //
>+ NodeNameLength = StrLen (NodeName);
>+ if (StrnCmp (Str, NodeName, NodeNameLength) != 0) {
>+ return NULL;
>+ }
>+
>+ ParamStr = Str + NodeNameLength;
>+ if (!IS_LEFT_PARENTH (*ParamStr)) {
>+ return NULL;
>+ }
>+
>+ //
>+ // Skip the found '(' and find first occurrence of ')'
>+ //
>+ ParamStr++;
>+ ParameterLength = 0;
>+ StrPointer = ParamStr;
>+ while (!IS_NULL (*StrPointer)) {
>+ if (IS_RIGHT_PARENTH (*StrPointer)) {
>+ break;
>+ }
>+ StrPointer++;
>+ ParameterLength++;
>+ }
>+ if (IS_NULL (*StrPointer)) {
>+ //
>+ // ')' not found
>+ //
>+ return NULL;
>+ }
>+
>+ ParamStr = AllocateCopyPool ((ParameterLength + 1) * sizeof (CHAR16),
>ParamStr);
>+ if (ParamStr == NULL) {
>+ return NULL;
>+ }
>+ //
>+ // Terminate the parameter string
>+ //
>+ ParamStr[ParameterLength] = L'\0';
>+
>+ return ParamStr;
>+}
>+
>+/**
>+ Gets current sub-string from a string list, before return
>+ the list header is moved to next sub-string. The sub-string is separated
>+ by the specified character. For example, the separator is ',', the string
>+ list is "2,0,3", it returns "2", the remain list move to "0,3"
>+
>+ @param List A string list separated by the specified separator
>+ @param Separator The separator character
>+
>+ @return A pointer to the current sub-string
>+
>+**/
>+CHAR16 *
>+SplitStr (
>+ CHAR16 **List,
>+ CHAR16 Separator
>+ )
>+{
>+ CHAR16 *Str;
>+ CHAR16 *ReturnStr;
>+
>+ Str = *List;
>+ ReturnStr = Str;
>+
>+ if (IS_NULL (*Str)) {
>+ return ReturnStr;
>+ }
>+
>+ //
>+ // Find first occurrence of the separator
>+ //
>+ while (!IS_NULL (*Str)) {
>+ if (*Str == Separator) {
>+ break;
>+ }
>+ Str++;
>+ }
>+
>+ if (*Str == Separator) {
>+ //
>+ // Find a sub-string, terminate it
>+ //
>+ *Str = L'\0';
>+ Str++;
>+ }
>+
>+ //
>+ // Move to next sub-string
>+ //
>+ *List = Str;
>+ return ReturnStr;
>+}
>+
>+/**
>+ Gets the next parameter string from the list.
>+
>+ @param List A string list separated by the specified separator
>+
>+ @return A pointer to the current sub-string
>+
>+**/
>+CHAR16 *
>+GetNextParamStr (
>+ CHAR16 **List
>+ )
>+{
>+ //
>+ // The separator is comma
>+ //
>+ return SplitStr (List, L',');
>+}
>+
>+/**
>+ Get one device node from entire device path text.
>+
>+ @param DevicePath On input, the current Device Path node; on output,
>the next device path node
>+ @param IsInstanceEnd This node is the end of a device path instance
>+
>+ @return A device node text or NULL if no more device node available
>+
>+**/
>+CHAR16 *
>+GetNextDeviceNodeStr (
>+ CHAR16 **DevicePath,
>+ BOOLEAN *IsInstanceEnd
>+ )
>+{
>+ CHAR16 *Str;
>+ CHAR16 *ReturnStr;
>+ UINTN ParenthesesStack;
>+
>+ Str = *DevicePath;
>+ if (IS_NULL (*Str)) {
>+ return NULL;
>+ }
>+
>+ //
>+ // Skip the leading '/', '(', ')' and ','
>+ //
>+ while (!IS_NULL (*Str)) {
>+ if (!IS_SLASH (*Str) &&
>+ !IS_COMMA (*Str) &&
>+ !IS_LEFT_PARENTH (*Str) &&
>+ !IS_RIGHT_PARENTH (*Str)) {
>+ break;
>+ }
>+ Str++;
>+ }
>+
>+ ReturnStr = Str;
>+
>+ //
>+ // Scan for the separator of this device node, '/' or ','
>+ //
>+ ParenthesesStack = 0;
>+ while (!IS_NULL (*Str)) {
>+ if ((IS_COMMA (*Str) || IS_SLASH (*Str)) && (ParenthesesStack == 0)) {
>+ break;
>+ }
>+
>+ if (IS_LEFT_PARENTH (*Str)) {
>+ ParenthesesStack++;
>+ } else if (IS_RIGHT_PARENTH (*Str)) {
>+ ParenthesesStack--;
>+ }
>+
>+ Str++;
>+ }
>+
>+ if (ParenthesesStack != 0) {
>+ //
>+ // The '(' doesn't pair with ')', invalid device path text
>+ //
>+ return NULL;
>+ }
>+
>+ if (IS_COMMA (*Str)) {
>+ *IsInstanceEnd = TRUE;
>+ *Str = L'\0';
>+ Str++;
>+ } else {
>+ *IsInstanceEnd = FALSE;
>+ if (!IS_NULL (*Str)) {
>+ *Str = L'\0';
>+ Str++;
>+ }
>+ }
>+
>+ *DevicePath = Str;
>+
>+ return ReturnStr;
>+}
>+
>+
>+/**
>+ Return whether the integer string is a hex string.
>+
>+ @param Str The integer string
>+
>+ @retval TRUE Hex string
>+ @retval FALSE Decimal string
>+
>+**/
>+BOOLEAN
>+IsHexStr (
>+ CHAR16 *Str
>+ )
>+{
>+ //
>+ // skip preceeding white space
>+ //
>+ while ((*Str != 0) && *Str == L' ') {
>+ Str ++;
>+ }
>+ //
>+ // skip preceeding zeros
>+ //
>+ while ((*Str != 0) && *Str == L'0') {
>+ Str ++;
>+ }
>+
>+ return (BOOLEAN) (*Str == L'x' || *Str == L'X');
>+}
>+
>+/**
>+
>+ Convert integer string to uint.
>+
>+ @param Str The integer string. If leading with "0x" or "0X", it's
>hexadecimal.
>+
>+ @return A UINTN value represented by Str
>+
>+**/
>+UINTN
>+Strtoi (
>+ CHAR16 *Str
>+ )
>+{
>+ if (IsHexStr (Str)) {
>+ return StrHexToUintn (Str);
>+ } else {
>+ return StrDecimalToUintn (Str);
>+ }
>+}
>+
>+/**
>+
>+ Convert integer string to 64 bit data.
>+
>+ @param Str The integer string. If leading with "0x" or "0X", it's
>hexadecimal.
>+ @param Data A pointer to the UINT64 value represented by Str
>+
>+**/
>+VOID
>+Strtoi64 (
>+ CHAR16 *Str,
>+ UINT64 *Data
>+ )
>+{
>+ if (IsHexStr (Str)) {
>+ *Data = StrHexToUint64 (Str);
>+ } else {
>+ *Data = StrDecimalToUint64 (Str);
>+ }
>+}
>+
>+/**
>+ Converts a Unicode string to ASCII string.
>+
>+ @param Str The equivalent Unicode string
>+ @param AsciiStr On input, it points to destination ASCII string buffer; on
>output, it points
>+ to the next ASCII string next to it
>+
>+**/
>+VOID
>+StrToAscii (
>+ CHAR16 *Str,
>+ CHAR8 **AsciiStr
>+ )
>+{
>+ CHAR8 *Dest;
>+
>+ Dest = *AsciiStr;
>+ while (!IS_NULL (*Str)) {
>+ *(Dest++) = (CHAR8) *(Str++);
>+ }
>+ *Dest = 0;
>+
>+ //
>+ // Return the string next to it
>+ //
>+ *AsciiStr = Dest + 1;
>+}
>+
>+/**
>+ Converts a generic text device path node to device path structure.
>+
>+ @param Type The type of the device path node.
>+ @param TextDeviceNode The input text device path node.
>+
>+ @return A pointer to device path structure.
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextGenericPath (
>+ UINT8 Type,
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ EFI_DEVICE_PATH_PROTOCOL *Node;
>+ CHAR16 *SubtypeStr;
>+ CHAR16 *DataStr;
>+ UINTN DataLength;
>+
>+ SubtypeStr = GetNextParamStr (&TextDeviceNode);
>+ DataStr = GetNextParamStr (&TextDeviceNode);
>+
>+ if (DataStr == NULL) {
>+ DataLength = 0;
>+ } else {
>+ DataLength = StrLen (DataStr) / 2;
>+ }
>+ Node = CreateDeviceNode (
>+ Type,
>+ (UINT8) Strtoi (SubtypeStr),
>+ (UINT16) (sizeof (EFI_DEVICE_PATH_PROTOCOL) + DataLength)
>+ );
>+
>+ StrHexToBytes (DataStr, DataLength * 2, (UINT8 *) (Node + 1), DataLength);
>+ return Node;
>+}
>+
>+/**
>+ Converts a generic text device path node to device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextPath (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *TypeStr;
>+
>+ TypeStr = GetNextParamStr (&TextDeviceNode);
>+
>+ return DevPathFromTextGenericPath ((UINT8) Strtoi (TypeStr),
>TextDeviceNode);
>+}
>+
>+/**
>+ Converts a generic hardware text device path node to Hardware device
>path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to Hardware device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextHardwarePath (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ return DevPathFromTextGenericPath (HARDWARE_DEVICE_PATH,
>TextDeviceNode);
>+}
>+
>+/**
>+ Converts a text device path node to Hardware PCI device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to Hardware PCI device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextPci (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *FunctionStr;
>+ CHAR16 *DeviceStr;
>+ PCI_DEVICE_PATH *Pci;
>+
>+ DeviceStr = GetNextParamStr (&TextDeviceNode);
>+ FunctionStr = GetNextParamStr (&TextDeviceNode);
>+ Pci = (PCI_DEVICE_PATH *) CreateDeviceNode (
>+ HARDWARE_DEVICE_PATH,
>+ HW_PCI_DP,
>+ (UINT16) sizeof (PCI_DEVICE_PATH)
>+ );
>+
>+ Pci->Function = (UINT8) Strtoi (FunctionStr);
>+ Pci->Device = (UINT8) Strtoi (DeviceStr);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Pci;
>+}
>+
>+/**
>+ Converts a text device path node to Hardware PC card device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to Hardware PC card device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextPcCard (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *FunctionNumberStr;
>+ PCCARD_DEVICE_PATH *Pccard;
>+
>+ FunctionNumberStr = GetNextParamStr (&TextDeviceNode);
>+ Pccard = (PCCARD_DEVICE_PATH *) CreateDeviceNode (
>+ HARDWARE_DEVICE_PATH,
>+ HW_PCCARD_DP,
>+ (UINT16) sizeof (PCCARD_DEVICE_PATH)
>+ );
>+
>+ Pccard->FunctionNumber = (UINT8) Strtoi (FunctionNumberStr);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Pccard;
>+}
>+
>+/**
>+ Converts a text device path node to Hardware memory map device path
>structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to Hardware memory map device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextMemoryMapped (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *MemoryTypeStr;
>+ CHAR16 *StartingAddressStr;
>+ CHAR16 *EndingAddressStr;
>+ MEMMAP_DEVICE_PATH *MemMap;
>+
>+ MemoryTypeStr = GetNextParamStr (&TextDeviceNode);
>+ StartingAddressStr = GetNextParamStr (&TextDeviceNode);
>+ EndingAddressStr = GetNextParamStr (&TextDeviceNode);
>+ MemMap = (MEMMAP_DEVICE_PATH *) CreateDeviceNode (
>+ HARDWARE_DEVICE_PATH,
>+ HW_MEMMAP_DP,
>+ (UINT16) sizeof (MEMMAP_DEVICE_PATH)
>+ );
>+
>+ MemMap->MemoryType = (UINT32) Strtoi (MemoryTypeStr);
>+ Strtoi64 (StartingAddressStr, &MemMap->StartingAddress);
>+ Strtoi64 (EndingAddressStr, &MemMap->EndingAddress);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) MemMap;
>+}
>+
>+/**
>+ Converts a text device path node to Vendor device path structure based on
>the input Type
>+ and SubType.
>+
>+ @param TextDeviceNode The input Text device path node.
>+ @param Type The type of device path node.
>+ @param SubType The subtype of device path node.
>+
>+ @return A pointer to the newly-created Vendor device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+ConvertFromTextVendor (
>+ CHAR16 *TextDeviceNode,
>+ UINT8 Type,
>+ UINT8 SubType
>+ )
>+{
>+ CHAR16 *GuidStr;
>+ CHAR16 *DataStr;
>+ UINTN Length;
>+ VENDOR_DEVICE_PATH *Vendor;
>+
>+ GuidStr = GetNextParamStr (&TextDeviceNode);
>+
>+ DataStr = GetNextParamStr (&TextDeviceNode);
>+ Length = StrLen (DataStr);
>+ //
>+ // Two hex characters make up 1 buffer byte
>+ //
>+ Length = (Length + 1) / 2;
>+
>+ Vendor = (VENDOR_DEVICE_PATH *) CreateDeviceNode (
>+ Type,
>+ SubType,
>+ (UINT16) (sizeof (VENDOR_DEVICE_PATH) + Length)
>+ );
>+
>+ StrToGuid (GuidStr, &Vendor->Guid);
>+ StrHexToBytes (DataStr, Length * 2, (UINT8 *) (Vendor + 1), Length);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Vendor;
>+}
>+
>+/**
>+ Converts a text device path node to Vendor Hardware device path
>structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created Vendor Hardware device path
>structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextVenHw (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ return ConvertFromTextVendor (
>+ TextDeviceNode,
>+ HARDWARE_DEVICE_PATH,
>+ HW_VENDOR_DP
>+ );
>+}
>+
>+/**
>+ Converts a text device path node to Hardware Controller device path
>structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created Hardware Controller device path
>structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextCtrl (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *ControllerStr;
>+ CONTROLLER_DEVICE_PATH *Controller;
>+
>+ ControllerStr = GetNextParamStr (&TextDeviceNode);
>+ Controller = (CONTROLLER_DEVICE_PATH *) CreateDeviceNode (
>+ HARDWARE_DEVICE_PATH,
>+ HW_CONTROLLER_DP,
>+ (UINT16) sizeof (CONTROLLER_DEVICE_PATH)
>+ );
>+ Controller->ControllerNumber = (UINT32) Strtoi (ControllerStr);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Controller;
>+}
>+
>+/**
>+ Converts a text device path node to BMC device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created BMC device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextBmc (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *InterfaceTypeStr;
>+ CHAR16 *BaseAddressStr;
>+ BMC_DEVICE_PATH *BmcDp;
>+
>+ InterfaceTypeStr = GetNextParamStr (&TextDeviceNode);
>+ BaseAddressStr = GetNextParamStr (&TextDeviceNode);
>+ BmcDp = (BMC_DEVICE_PATH *) CreateDeviceNode (
>+ HARDWARE_DEVICE_PATH,
>+ HW_BMC_DP,
>+ (UINT16) sizeof (BMC_DEVICE_PATH)
>+ );
>+
>+ BmcDp->InterfaceType = (UINT8) Strtoi (InterfaceTypeStr);
>+ WriteUnaligned64 (
>+ (UINT64 *) (&BmcDp->BaseAddress),
>+ StrHexToUint64 (BaseAddressStr)
>+ );
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) BmcDp;
>+}
>+
>+/**
>+ Converts a generic ACPI text device path node to ACPI device path
>structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to ACPI device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextAcpiPath (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ return DevPathFromTextGenericPath (ACPI_DEVICE_PATH,
>TextDeviceNode);
>+}
>+
>+/**
>+ Converts a string to EisaId.
>+
>+ @param Text The input string.
>+
>+ @return UINT32 EISA ID.
>+**/
>+UINT32
>+EisaIdFromText (
>+ CHAR16 *Text
>+ )
>+{
>+ return (((Text[0] - 'A' + 1) & 0x1f) << 10)
>+ + (((Text[1] - 'A' + 1) & 0x1f) << 5)
>+ + (((Text[2] - 'A' + 1) & 0x1f) << 0)
>+ + (UINT32) (StrHexToUintn (&Text[3]) << 16)
>+ ;
>+}
>+
>+/**
>+ Converts a text device path node to ACPI HID device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created ACPI HID device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextAcpi (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *HIDStr;
>+ CHAR16 *UIDStr;
>+ ACPI_HID_DEVICE_PATH *Acpi;
>+
>+ HIDStr = GetNextParamStr (&TextDeviceNode);
>+ UIDStr = GetNextParamStr (&TextDeviceNode);
>+ Acpi = (ACPI_HID_DEVICE_PATH *) CreateDeviceNode (
>+ ACPI_DEVICE_PATH,
>+ ACPI_DP,
>+ (UINT16) sizeof (ACPI_HID_DEVICE_PATH)
>+ );
>+
>+ Acpi->HID = EisaIdFromText (HIDStr);
>+ Acpi->UID = (UINT32) Strtoi (UIDStr);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Acpi;
>+}
>+
>+/**
>+ Converts a text device path node to ACPI HID device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+ @param PnPId The input plug and play identification.
>+
>+ @return A pointer to the newly-created ACPI HID device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+ConvertFromTextAcpi (
>+ CHAR16 *TextDeviceNode,
>+ UINT32 PnPId
>+ )
>+{
>+ CHAR16 *UIDStr;
>+ ACPI_HID_DEVICE_PATH *Acpi;
>+
>+ UIDStr = GetNextParamStr (&TextDeviceNode);
>+ Acpi = (ACPI_HID_DEVICE_PATH *) CreateDeviceNode (
>+ ACPI_DEVICE_PATH,
>+ ACPI_DP,
>+ (UINT16) sizeof (ACPI_HID_DEVICE_PATH)
>+ );
>+
>+ Acpi->HID = EFI_PNP_ID (PnPId);
>+ Acpi->UID = (UINT32) Strtoi (UIDStr);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Acpi;
>+}
>+
>+/**
>+ Converts a text device path node to PCI root device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created PCI root device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextPciRoot (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ return ConvertFromTextAcpi (TextDeviceNode, 0x0a03);
>+}
>+
>+/**
>+ Converts a text device path node to PCIE root device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created PCIE root device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextPcieRoot (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ return ConvertFromTextAcpi (TextDeviceNode, 0x0a08);
>+}
>+
>+/**
>+ Converts a text device path node to Floppy device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created Floppy device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextFloppy (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ return ConvertFromTextAcpi (TextDeviceNode, 0x0604);
>+}
>+
>+/**
>+ Converts a text device path node to Keyboard device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created Keyboard device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextKeyboard (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ return ConvertFromTextAcpi (TextDeviceNode, 0x0301);
>+}
>+
>+/**
>+ Converts a text device path node to Serial device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created Serial device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextSerial (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ return ConvertFromTextAcpi (TextDeviceNode, 0x0501);
>+}
>+
>+/**
>+ Converts a text device path node to Parallel Port device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created Parallel Port device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextParallelPort (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ return ConvertFromTextAcpi (TextDeviceNode, 0x0401);
>+}
>+
>+/**
>+ Converts a text device path node to ACPI extension device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created ACPI extension device path
>structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextAcpiEx (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *HIDStr;
>+ CHAR16 *CIDStr;
>+ CHAR16 *UIDStr;
>+ CHAR16 *HIDSTRStr;
>+ CHAR16 *CIDSTRStr;
>+ CHAR16 *UIDSTRStr;
>+ CHAR8 *AsciiStr;
>+ UINT16 Length;
>+ ACPI_EXTENDED_HID_DEVICE_PATH *AcpiEx;
>+
>+ HIDStr = GetNextParamStr (&TextDeviceNode);
>+ CIDStr = GetNextParamStr (&TextDeviceNode);
>+ UIDStr = GetNextParamStr (&TextDeviceNode);
>+ HIDSTRStr = GetNextParamStr (&TextDeviceNode);
>+ CIDSTRStr = GetNextParamStr (&TextDeviceNode);
>+ UIDSTRStr = GetNextParamStr (&TextDeviceNode);
>+
>+ Length = (UINT16) (sizeof (ACPI_EXTENDED_HID_DEVICE_PATH) + StrLen
>(HIDSTRStr) + 1);
>+ Length = (UINT16) (Length + StrLen (UIDSTRStr) + 1);
>+ Length = (UINT16) (Length + StrLen (CIDSTRStr) + 1);
>+ AcpiEx = (ACPI_EXTENDED_HID_DEVICE_PATH *) CreateDeviceNode (
>+ ACPI_DEVICE_PATH,
>+ ACPI_EXTENDED_DP,
>+ Length
>+ );
>+
>+ AcpiEx->HID = EisaIdFromText (HIDStr);
>+ AcpiEx->CID = EisaIdFromText (CIDStr);
>+ AcpiEx->UID = (UINT32) Strtoi (UIDStr);
>+
>+ AsciiStr = (CHAR8 *) ((UINT8 *)AcpiEx + sizeof
>(ACPI_EXTENDED_HID_DEVICE_PATH));
>+ StrToAscii (HIDSTRStr, &AsciiStr);
>+ StrToAscii (UIDSTRStr, &AsciiStr);
>+ StrToAscii (CIDSTRStr, &AsciiStr);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) AcpiEx;
>+}
>+
>+/**
>+ Converts a text device path node to ACPI extension device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created ACPI extension device path
>structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextAcpiExp (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *HIDStr;
>+ CHAR16 *CIDStr;
>+ CHAR16 *UIDSTRStr;
>+ CHAR8 *AsciiStr;
>+ UINT16 Length;
>+ ACPI_EXTENDED_HID_DEVICE_PATH *AcpiEx;
>+
>+ HIDStr = GetNextParamStr (&TextDeviceNode);
>+ CIDStr = GetNextParamStr (&TextDeviceNode);
>+ UIDSTRStr = GetNextParamStr (&TextDeviceNode);
>+ Length = (UINT16) (sizeof (ACPI_EXTENDED_HID_DEVICE_PATH) + StrLen
>(UIDSTRStr) + 3);
>+ AcpiEx = (ACPI_EXTENDED_HID_DEVICE_PATH *) CreateDeviceNode (
>+ ACPI_DEVICE_PATH,
>+ ACPI_EXTENDED_DP,
>+ Length
>+ );
>+
>+ AcpiEx->HID = EisaIdFromText (HIDStr);
>+ AcpiEx->CID = EisaIdFromText (CIDStr);
>+ AcpiEx->UID = 0;
>+
>+ AsciiStr = (CHAR8 *) ((UINT8 *)AcpiEx + sizeof
>(ACPI_EXTENDED_HID_DEVICE_PATH));
>+ //
>+ // HID string is NULL
>+ //
>+ *AsciiStr = '\0';
>+ //
>+ // Convert UID string
>+ //
>+ AsciiStr++;
>+ StrToAscii (UIDSTRStr, &AsciiStr);
>+ //
>+ // CID string is NULL
>+ //
>+ *AsciiStr = '\0';
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) AcpiEx;
>+}
>+
>+/**
>+ Converts a text device path node to ACPI _ADR device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created ACPI _ADR device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextAcpiAdr (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *DisplayDeviceStr;
>+ ACPI_ADR_DEVICE_PATH *AcpiAdr;
>+ UINTN Index;
>+ UINTN Length;
>+
>+ AcpiAdr = (ACPI_ADR_DEVICE_PATH *) CreateDeviceNode (
>+ ACPI_DEVICE_PATH,
>+ ACPI_ADR_DP,
>+ (UINT16) sizeof (ACPI_ADR_DEVICE_PATH)
>+ );
>+ ASSERT (AcpiAdr != NULL);
>+
>+ for (Index = 0; ; Index++) {
>+ DisplayDeviceStr = GetNextParamStr (&TextDeviceNode);
>+ if (IS_NULL (*DisplayDeviceStr)) {
>+ break;
>+ }
>+ if (Index > 0) {
>+ Length = DevicePathNodeLength (AcpiAdr);
>+ AcpiAdr = ReallocatePool (
>+ Length,
>+ Length + sizeof (UINT32),
>+ AcpiAdr
>+ );
>+ ASSERT (AcpiAdr != NULL);
>+ SetDevicePathNodeLength (AcpiAdr, Length + sizeof (UINT32));
>+ }
>+
>+ (&AcpiAdr->ADR)[Index] = (UINT32) Strtoi (DisplayDeviceStr);
>+ }
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) AcpiAdr;
>+}
>+
>+/**
>+ Converts a generic messaging text device path node to messaging device
>path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to messaging device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextMsg (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ return DevPathFromTextGenericPath (MESSAGING_DEVICE_PATH,
>TextDeviceNode);
>+}
>+
>+/**
>+ Converts a text device path node to Parallel Port device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created Parallel Port device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextAta (
>+ CHAR16 *TextDeviceNode
>+)
>+{
>+ CHAR16 *PrimarySecondaryStr;
>+ CHAR16 *SlaveMasterStr;
>+ CHAR16 *LunStr;
>+ ATAPI_DEVICE_PATH *Atapi;
>+
>+ Atapi = (ATAPI_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_ATAPI_DP,
>+ (UINT16) sizeof (ATAPI_DEVICE_PATH)
>+ );
>+
>+ PrimarySecondaryStr = GetNextParamStr (&TextDeviceNode);
>+ SlaveMasterStr = GetNextParamStr (&TextDeviceNode);
>+ LunStr = GetNextParamStr (&TextDeviceNode);
>+
>+ if (StrCmp (PrimarySecondaryStr, L"Primary") == 0) {
>+ Atapi->PrimarySecondary = 0;
>+ } else if (StrCmp (PrimarySecondaryStr, L"Secondary") == 0) {
>+ Atapi->PrimarySecondary = 1;
>+ } else {
>+ Atapi->PrimarySecondary = (UINT8) Strtoi (PrimarySecondaryStr);
>+ }
>+ if (StrCmp (SlaveMasterStr, L"Master") == 0) {
>+ Atapi->SlaveMaster = 0;
>+ } else if (StrCmp (SlaveMasterStr, L"Slave") == 0) {
>+ Atapi->SlaveMaster = 1;
>+ } else {
>+ Atapi->SlaveMaster = (UINT8) Strtoi (SlaveMasterStr);
>+ }
>+
>+ Atapi->Lun = (UINT16) Strtoi (LunStr);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Atapi;
>+}
>+
>+/**
>+ Converts a text device path node to SCSI device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created SCSI device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextScsi (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *PunStr;
>+ CHAR16 *LunStr;
>+ SCSI_DEVICE_PATH *Scsi;
>+
>+ PunStr = GetNextParamStr (&TextDeviceNode);
>+ LunStr = GetNextParamStr (&TextDeviceNode);
>+ Scsi = (SCSI_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_SCSI_DP,
>+ (UINT16) sizeof (SCSI_DEVICE_PATH)
>+ );
>+
>+ Scsi->Pun = (UINT16) Strtoi (PunStr);
>+ Scsi->Lun = (UINT16) Strtoi (LunStr);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Scsi;
>+}
>+
>+/**
>+ Converts a text device path node to Fibre device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created Fibre device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextFibre (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *WWNStr;
>+ CHAR16 *LunStr;
>+ FIBRECHANNEL_DEVICE_PATH *Fibre;
>+
>+ WWNStr = GetNextParamStr (&TextDeviceNode);
>+ LunStr = GetNextParamStr (&TextDeviceNode);
>+ Fibre = (FIBRECHANNEL_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_FIBRECHANNEL_DP,
>+ (UINT16) sizeof (FIBRECHANNEL_DEVICE_PATH)
>+ );
>+
>+ Fibre->Reserved = 0;
>+ Strtoi64 (WWNStr, &Fibre->WWN);
>+ Strtoi64 (LunStr, &Fibre->Lun);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Fibre;
>+}
>+
>+/**
>+ Converts a text device path node to FibreEx device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created FibreEx device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextFibreEx (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *WWNStr;
>+ CHAR16 *LunStr;
>+ FIBRECHANNELEX_DEVICE_PATH *FibreEx;
>+
>+ WWNStr = GetNextParamStr (&TextDeviceNode);
>+ LunStr = GetNextParamStr (&TextDeviceNode);
>+ FibreEx = (FIBRECHANNELEX_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_FIBRECHANNELEX_DP,
>+ (UINT16) sizeof (FIBRECHANNELEX_DEVICE_PATH)
>+ );
>+
>+ FibreEx->Reserved = 0;
>+ Strtoi64 (WWNStr, (UINT64 *) (&FibreEx->WWN));
>+ Strtoi64 (LunStr, (UINT64 *) (&FibreEx->Lun));
>+
>+ *(UINT64 *) (&FibreEx->WWN) = SwapBytes64 (*(UINT64 *) (&FibreEx-
>>WWN));
>+ *(UINT64 *) (&FibreEx->Lun) = SwapBytes64 (*(UINT64 *) (&FibreEx->Lun));
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) FibreEx;
>+}
>+
>+/**
>+ Converts a text device path node to 1394 device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created 1394 device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromText1394 (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *GuidStr;
>+ F1394_DEVICE_PATH *F1394DevPath;
>+
>+ GuidStr = GetNextParamStr (&TextDeviceNode);
>+ F1394DevPath = (F1394_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_1394_DP,
>+ (UINT16) sizeof (F1394_DEVICE_PATH)
>+ );
>+
>+ F1394DevPath->Reserved = 0;
>+ F1394DevPath->Guid = StrHexToUint64 (GuidStr);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) F1394DevPath;
>+}
>+
>+/**
>+ Converts a text device path node to USB device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created USB device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextUsb (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *PortStr;
>+ CHAR16 *InterfaceStr;
>+ USB_DEVICE_PATH *Usb;
>+
>+ PortStr = GetNextParamStr (&TextDeviceNode);
>+ InterfaceStr = GetNextParamStr (&TextDeviceNode);
>+ Usb = (USB_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_USB_DP,
>+ (UINT16) sizeof (USB_DEVICE_PATH)
>+ );
>+
>+ Usb->ParentPortNumber = (UINT8) Strtoi (PortStr);
>+ Usb->InterfaceNumber = (UINT8) Strtoi (InterfaceStr);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Usb;
>+}
>+
>+/**
>+ Converts a text device path node to I20 device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created I20 device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextI2O (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *TIDStr;
>+ I2O_DEVICE_PATH *I2ODevPath;
>+
>+ TIDStr = GetNextParamStr (&TextDeviceNode);
>+ I2ODevPath = (I2O_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_I2O_DP,
>+ (UINT16) sizeof (I2O_DEVICE_PATH)
>+ );
>+
>+ I2ODevPath->Tid = (UINT32) Strtoi (TIDStr);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) I2ODevPath;
>+}
>+
>+/**
>+ Converts a text device path node to Infini Band device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created Infini Band device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextInfiniband (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *FlagsStr;
>+ CHAR16 *GuidStr;
>+ CHAR16 *SidStr;
>+ CHAR16 *TidStr;
>+ CHAR16 *DidStr;
>+ INFINIBAND_DEVICE_PATH *InfiniBand;
>+
>+ FlagsStr = GetNextParamStr (&TextDeviceNode);
>+ GuidStr = GetNextParamStr (&TextDeviceNode);
>+ SidStr = GetNextParamStr (&TextDeviceNode);
>+ TidStr = GetNextParamStr (&TextDeviceNode);
>+ DidStr = GetNextParamStr (&TextDeviceNode);
>+ InfiniBand = (INFINIBAND_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_INFINIBAND_DP,
>+ (UINT16) sizeof (INFINIBAND_DEVICE_PATH)
>+ );
>+
>+ InfiniBand->ResourceFlags = (UINT32) Strtoi (FlagsStr);
>+ StrToGuid (GuidStr, (EFI_GUID *) InfiniBand->PortGid);
>+ Strtoi64 (SidStr, &InfiniBand->ServiceId);
>+ Strtoi64 (TidStr, &InfiniBand->TargetPortId);
>+ Strtoi64 (DidStr, &InfiniBand->DeviceId);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) InfiniBand;
>+}
>+
>+/**
>+ Converts a text device path node to Vendor-Defined Messaging device
>path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created Vendor-Defined Messaging device
>path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextVenMsg (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ return ConvertFromTextVendor (
>+ TextDeviceNode,
>+ MESSAGING_DEVICE_PATH,
>+ MSG_VENDOR_DP
>+ );
>+}
>+
>+/**
>+ Converts a text device path node to Vendor defined PC-ANSI device path
>structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created Vendor defined PC-ANSI device
>path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextVenPcAnsi (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ VENDOR_DEVICE_PATH *Vendor;
>+
>+ Vendor = (VENDOR_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_VENDOR_DP,
>+ (UINT16) sizeof (VENDOR_DEVICE_PATH));
>+ CopyGuid (&Vendor->Guid, &gEfiPcAnsiGuid);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Vendor;
>+}
>+
>+/**
>+ Converts a text device path node to Vendor defined VT100 device path
>structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created Vendor defined VT100 device path
>structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextVenVt100 (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ VENDOR_DEVICE_PATH *Vendor;
>+
>+ Vendor = (VENDOR_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_VENDOR_DP,
>+ (UINT16) sizeof (VENDOR_DEVICE_PATH));
>+ CopyGuid (&Vendor->Guid, &gEfiVT100Guid);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Vendor;
>+}
>+
>+/**
>+ Converts a text device path node to Vendor defined VT100 Plus device path
>structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created Vendor defined VT100 Plus device
>path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextVenVt100Plus (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ VENDOR_DEVICE_PATH *Vendor;
>+
>+ Vendor = (VENDOR_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_VENDOR_DP,
>+ (UINT16) sizeof (VENDOR_DEVICE_PATH));
>+ CopyGuid (&Vendor->Guid, &gEfiVT100PlusGuid);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Vendor;
>+}
>+
>+/**
>+ Converts a text device path node to Vendor defined UTF8 device path
>structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created Vendor defined UTF8 device path
>structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextVenUtf8 (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ VENDOR_DEVICE_PATH *Vendor;
>+
>+ Vendor = (VENDOR_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_VENDOR_DP,
>+ (UINT16) sizeof (VENDOR_DEVICE_PATH));
>+ CopyGuid (&Vendor->Guid, &gEfiVTUTF8Guid);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Vendor;
>+}
>+
>+/**
>+ Converts a text device path node to UART Flow Control device path
>structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created UART Flow Control device path
>structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextUartFlowCtrl (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *ValueStr;
>+ UART_FLOW_CONTROL_DEVICE_PATH *UartFlowControl;
>+
>+ ValueStr = GetNextParamStr (&TextDeviceNode);
>+ UartFlowControl = (UART_FLOW_CONTROL_DEVICE_PATH *)
>CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_VENDOR_DP,
>+ (UINT16) sizeof
>(UART_FLOW_CONTROL_DEVICE_PATH)
>+ );
>+
>+ CopyGuid (&UartFlowControl->Guid, &gEfiUartDevicePathGuid);
>+ if (StrCmp (ValueStr, L"XonXoff") == 0) {
>+ UartFlowControl->FlowControlMap = 2;
>+ } else if (StrCmp (ValueStr, L"Hardware") == 0) {
>+ UartFlowControl->FlowControlMap = 1;
>+ } else {
>+ UartFlowControl->FlowControlMap = 0;
>+ }
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) UartFlowControl;
>+}
>+
>+/**
>+ Converts a text device path node to Serial Attached SCSI device path
>structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created Serial Attached SCSI device path
>structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextSAS (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *AddressStr;
>+ CHAR16 *LunStr;
>+ CHAR16 *RTPStr;
>+ CHAR16 *SASSATAStr;
>+ CHAR16 *LocationStr;
>+ CHAR16 *ConnectStr;
>+ CHAR16 *DriveBayStr;
>+ CHAR16 *ReservedStr;
>+ UINT16 Info;
>+ UINT16 Uint16;
>+ SAS_DEVICE_PATH *Sas;
>+
>+ AddressStr = GetNextParamStr (&TextDeviceNode);
>+ LunStr = GetNextParamStr (&TextDeviceNode);
>+ RTPStr = GetNextParamStr (&TextDeviceNode);
>+ SASSATAStr = GetNextParamStr (&TextDeviceNode);
>+ LocationStr = GetNextParamStr (&TextDeviceNode);
>+ ConnectStr = GetNextParamStr (&TextDeviceNode);
>+ DriveBayStr = GetNextParamStr (&TextDeviceNode);
>+ ReservedStr = GetNextParamStr (&TextDeviceNode);
>+ Sas = (SAS_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_VENDOR_DP,
>+ (UINT16) sizeof (SAS_DEVICE_PATH)
>+ );
>+
>+ CopyGuid (&Sas->Guid, &gEfiSasDevicePathGuid);
>+ Strtoi64 (AddressStr, &Sas->SasAddress);
>+ Strtoi64 (LunStr, &Sas->Lun);
>+ Sas->RelativeTargetPort = (UINT16) Strtoi (RTPStr);
>+
>+ if (StrCmp (SASSATAStr, L"NoTopology") == 0) {
>+ Info = 0x0;
>+
>+ } else if ((StrCmp (SASSATAStr, L"SATA") == 0) || (StrCmp (SASSATAStr,
>L"SAS") == 0)) {
>+
>+ Uint16 = (UINT16) Strtoi (DriveBayStr);
>+ if (Uint16 == 0) {
>+ Info = 0x1;
>+ } else {
>+ Info = (UINT16) (0x2 | ((Uint16 - 1) << 8));
>+ }
>+
>+ if (StrCmp (SASSATAStr, L"SATA") == 0) {
>+ Info |= BIT4;
>+ }
>+
>+ //
>+ // Location is an integer between 0 and 1 or else
>+ // the keyword Internal (0) or External (1).
>+ //
>+ if (StrCmp (LocationStr, L"External") == 0) {
>+ Uint16 = 1;
>+ } else if (StrCmp (LocationStr, L"Internal") == 0) {
>+ Uint16 = 0;
>+ } else {
>+ Uint16 = ((UINT16) Strtoi (LocationStr) & BIT0);
>+ }
>+ Info |= (Uint16 << 5);
>+
>+ //
>+ // Connect is an integer between 0 and 3 or else
>+ // the keyword Direct (0) or Expanded (1).
>+ //
>+ if (StrCmp (ConnectStr, L"Expanded") == 0) {
>+ Uint16 = 1;
>+ } else if (StrCmp (ConnectStr, L"Direct") == 0) {
>+ Uint16 = 0;
>+ } else {
>+ Uint16 = ((UINT16) Strtoi (ConnectStr) & (BIT0 | BIT1));
>+ }
>+ Info |= (Uint16 << 6);
>+
>+ } else {
>+ Info = (UINT16) Strtoi (SASSATAStr);
>+ }
>+
>+ Sas->DeviceTopology = Info;
>+ Sas->Reserved = (UINT32) Strtoi (ReservedStr);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Sas;
>+}
>+
>+/**
>+ Converts a text device path node to Serial Attached SCSI Ex device path
>structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created Serial Attached SCSI Ex device path
>structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextSasEx (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *AddressStr;
>+ CHAR16 *LunStr;
>+ CHAR16 *RTPStr;
>+ CHAR16 *SASSATAStr;
>+ CHAR16 *LocationStr;
>+ CHAR16 *ConnectStr;
>+ CHAR16 *DriveBayStr;
>+ UINT16 Info;
>+ UINT16 Uint16;
>+ UINT64 SasAddress;
>+ UINT64 Lun;
>+ SASEX_DEVICE_PATH *SasEx;
>+
>+ AddressStr = GetNextParamStr (&TextDeviceNode);
>+ LunStr = GetNextParamStr (&TextDeviceNode);
>+ RTPStr = GetNextParamStr (&TextDeviceNode);
>+ SASSATAStr = GetNextParamStr (&TextDeviceNode);
>+ LocationStr = GetNextParamStr (&TextDeviceNode);
>+ ConnectStr = GetNextParamStr (&TextDeviceNode);
>+ DriveBayStr = GetNextParamStr (&TextDeviceNode);
>+ SasEx = (SASEX_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_SASEX_DP,
>+ (UINT16) sizeof (SASEX_DEVICE_PATH)
>+ );
>+
>+ Strtoi64 (AddressStr, &SasAddress);
>+ Strtoi64 (LunStr, &Lun);
>+ WriteUnaligned64 ((UINT64 *) &SasEx->SasAddress, SwapBytes64
>(SasAddress));
>+ WriteUnaligned64 ((UINT64 *) &SasEx->Lun, SwapBytes64 (Lun));
>+ SasEx->RelativeTargetPort = (UINT16) Strtoi (RTPStr);
>+
>+ if (StrCmp (SASSATAStr, L"NoTopology") == 0) {
>+ Info = 0x0;
>+
>+ } else if ((StrCmp (SASSATAStr, L"SATA") == 0) || (StrCmp (SASSATAStr,
>L"SAS") == 0)) {
>+
>+ Uint16 = (UINT16) Strtoi (DriveBayStr);
>+ if (Uint16 == 0) {
>+ Info = 0x1;
>+ } else {
>+ Info = (UINT16) (0x2 | ((Uint16 - 1) << 8));
>+ }
>+
>+ if (StrCmp (SASSATAStr, L"SATA") == 0) {
>+ Info |= BIT4;
>+ }
>+
>+ //
>+ // Location is an integer between 0 and 1 or else
>+ // the keyword Internal (0) or External (1).
>+ //
>+ if (StrCmp (LocationStr, L"External") == 0) {
>+ Uint16 = 1;
>+ } else if (StrCmp (LocationStr, L"Internal") == 0) {
>+ Uint16 = 0;
>+ } else {
>+ Uint16 = ((UINT16) Strtoi (LocationStr) & BIT0);
>+ }
>+ Info |= (Uint16 << 5);
>+
>+ //
>+ // Connect is an integer between 0 and 3 or else
>+ // the keyword Direct (0) or Expanded (1).
>+ //
>+ if (StrCmp (ConnectStr, L"Expanded") == 0) {
>+ Uint16 = 1;
>+ } else if (StrCmp (ConnectStr, L"Direct") == 0) {
>+ Uint16 = 0;
>+ } else {
>+ Uint16 = ((UINT16) Strtoi (ConnectStr) & (BIT0 | BIT1));
>+ }
>+ Info |= (Uint16 << 6);
>+
>+ } else {
>+ Info = (UINT16) Strtoi (SASSATAStr);
>+ }
>+
>+ SasEx->DeviceTopology = Info;
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) SasEx;
>+}
>+
>+/**
>+ Converts a text device path node to NVM Express Namespace device path
>structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created NVM Express Namespace device
>path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextNVMe (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *NamespaceIdStr;
>+ CHAR16 *NamespaceUuidStr;
>+ NVME_NAMESPACE_DEVICE_PATH *Nvme;
>+ UINT8 *Uuid;
>+ UINTN Index;
>+
>+ NamespaceIdStr = GetNextParamStr (&TextDeviceNode);
>+ NamespaceUuidStr = GetNextParamStr (&TextDeviceNode);
>+ Nvme = (NVME_NAMESPACE_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_NVME_NAMESPACE_DP,
>+ (UINT16) sizeof (NVME_NAMESPACE_DEVICE_PATH)
>+ );
>+
>+ Nvme->NamespaceId = (UINT32) Strtoi (NamespaceIdStr);
>+ Uuid = (UINT8 *) &Nvme->NamespaceUuid;
>+
>+ Index = sizeof (Nvme->NamespaceUuid) / sizeof (UINT8);
>+ while (Index-- != 0) {
>+ Uuid[Index] = (UINT8) StrHexToUintn (SplitStr (&NamespaceUuidStr, L'-'));
>+ }
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Nvme;
>+}
>+
>+/**
>+ Converts a text device path node to UFS device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created UFS device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextUfs (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *PunStr;
>+ CHAR16 *LunStr;
>+ UFS_DEVICE_PATH *Ufs;
>+
>+ PunStr = GetNextParamStr (&TextDeviceNode);
>+ LunStr = GetNextParamStr (&TextDeviceNode);
>+ Ufs = (UFS_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_UFS_DP,
>+ (UINT16) sizeof (UFS_DEVICE_PATH)
>+ );
>+
>+ Ufs->Pun = (UINT8) Strtoi (PunStr);
>+ Ufs->Lun = (UINT8) Strtoi (LunStr);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Ufs;
>+}
>+
>+/**
>+ Converts a text device path node to SD (Secure Digital) device path
>structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created SD device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextSd (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *SlotNumberStr;
>+ SD_DEVICE_PATH *Sd;
>+
>+ SlotNumberStr = GetNextParamStr (&TextDeviceNode);
>+ Sd = (SD_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_SD_DP,
>+ (UINT16) sizeof (SD_DEVICE_PATH)
>+ );
>+
>+ Sd->SlotNumber = (UINT8) Strtoi (SlotNumberStr);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Sd;
>+}
>+
>+/**
>+ Converts a text device path node to EMMC (Embedded MMC) device path
>structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created EMMC device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextEmmc (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *SlotNumberStr;
>+ EMMC_DEVICE_PATH *Emmc;
>+
>+ SlotNumberStr = GetNextParamStr (&TextDeviceNode);
>+ Emmc = (EMMC_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_EMMC_DP,
>+ (UINT16) sizeof (EMMC_DEVICE_PATH)
>+ );
>+
>+ Emmc->SlotNumber = (UINT8) Strtoi (SlotNumberStr);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Emmc;
>+}
>+
>+/**
>+ Converts a text device path node to Debug Port device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created Debug Port device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextDebugPort (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ VENDOR_DEFINED_MESSAGING_DEVICE_PATH *Vend;
>+
>+ Vend = (VENDOR_DEFINED_MESSAGING_DEVICE_PATH *)
>CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_VENDOR_DP,
>+ (UINT16) sizeof
>(VENDOR_DEFINED_MESSAGING_DEVICE_PATH)
>+ );
>+
>+ CopyGuid (&Vend->Guid, &gEfiDebugPortDevicePathGuid);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Vend;
>+}
>+
>+/**
>+ Converts a text device path node to MAC device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created MAC device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextMAC (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *AddressStr;
>+ CHAR16 *IfTypeStr;
>+ UINTN Length;
>+ MAC_ADDR_DEVICE_PATH *MACDevPath;
>+
>+ AddressStr = GetNextParamStr (&TextDeviceNode);
>+ IfTypeStr = GetNextParamStr (&TextDeviceNode);
>+ MACDevPath = (MAC_ADDR_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_MAC_ADDR_DP,
>+ (UINT16) sizeof (MAC_ADDR_DEVICE_PATH)
>+ );
>+
>+ MACDevPath->IfType = (UINT8) Strtoi (IfTypeStr);
>+
>+ Length = sizeof (EFI_MAC_ADDRESS);
>+ if (MACDevPath->IfType == 0x01 || MACDevPath->IfType == 0x00) {
>+ Length = 6;
>+ }
>+
>+ StrHexToBytes (AddressStr, Length * 2, MACDevPath->MacAddress.Addr,
>Length);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) MACDevPath;
>+}
>+
>+
>+/**
>+ Converts a text format to the network protocol ID.
>+
>+ @param Text String of protocol field.
>+
>+ @return Network protocol ID .
>+
>+**/
>+UINTN
>+NetworkProtocolFromText (
>+ CHAR16 *Text
>+ )
>+{
>+ if (StrCmp (Text, L"UDP") == 0) {
>+ return RFC_1700_UDP_PROTOCOL;
>+ }
>+
>+ if (StrCmp (Text, L"TCP") == 0) {
>+ return RFC_1700_TCP_PROTOCOL;
>+ }
>+
>+ return Strtoi (Text);
>+}
>+
>+
>+/**
>+ Converts a text device path node to IPV4 device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created IPV4 device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextIPv4 (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *RemoteIPStr;
>+ CHAR16 *ProtocolStr;
>+ CHAR16 *TypeStr;
>+ CHAR16 *LocalIPStr;
>+ CHAR16 *GatewayIPStr;
>+ CHAR16 *SubnetMaskStr;
>+ IPv4_DEVICE_PATH *IPv4;
>+
>+ RemoteIPStr = GetNextParamStr (&TextDeviceNode);
>+ ProtocolStr = GetNextParamStr (&TextDeviceNode);
>+ TypeStr = GetNextParamStr (&TextDeviceNode);
>+ LocalIPStr = GetNextParamStr (&TextDeviceNode);
>+ GatewayIPStr = GetNextParamStr (&TextDeviceNode);
>+ SubnetMaskStr = GetNextParamStr (&TextDeviceNode);
>+ IPv4 = (IPv4_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_IPv4_DP,
>+ (UINT16) sizeof (IPv4_DEVICE_PATH)
>+ );
>+
>+ StrToIpv4Address (RemoteIPStr, NULL, &IPv4->RemoteIpAddress, NULL);
>+ IPv4->Protocol = (UINT16) NetworkProtocolFromText (ProtocolStr);
>+ if (StrCmp (TypeStr, L"Static") == 0) {
>+ IPv4->StaticIpAddress = TRUE;
>+ } else {
>+ IPv4->StaticIpAddress = FALSE;
>+ }
>+
>+ StrToIpv4Address (LocalIPStr, NULL, &IPv4->LocalIpAddress, NULL);
>+ if (!IS_NULL (*GatewayIPStr) && !IS_NULL (*SubnetMaskStr)) {
>+ StrToIpv4Address (GatewayIPStr, NULL, &IPv4->GatewayIpAddress,
>NULL);
>+ StrToIpv4Address (SubnetMaskStr, NULL, &IPv4->SubnetMask, NULL);
>+ } else {
>+ ZeroMem (&IPv4->GatewayIpAddress, sizeof (IPv4->GatewayIpAddress));
>+ ZeroMem (&IPv4->SubnetMask, sizeof (IPv4->SubnetMask));
>+ }
>+
>+ IPv4->LocalPort = 0;
>+ IPv4->RemotePort = 0;
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) IPv4;
>+}
>+
>+/**
>+ Converts a text device path node to IPV6 device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created IPV6 device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextIPv6 (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *RemoteIPStr;
>+ CHAR16 *ProtocolStr;
>+ CHAR16 *TypeStr;
>+ CHAR16 *LocalIPStr;
>+ CHAR16 *GatewayIPStr;
>+ CHAR16 *PrefixLengthStr;
>+ IPv6_DEVICE_PATH *IPv6;
>+
>+ RemoteIPStr = GetNextParamStr (&TextDeviceNode);
>+ ProtocolStr = GetNextParamStr (&TextDeviceNode);
>+ TypeStr = GetNextParamStr (&TextDeviceNode);
>+ LocalIPStr = GetNextParamStr (&TextDeviceNode);
>+ PrefixLengthStr = GetNextParamStr (&TextDeviceNode);
>+ GatewayIPStr = GetNextParamStr (&TextDeviceNode);
>+ IPv6 = (IPv6_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_IPv6_DP,
>+ (UINT16) sizeof (IPv6_DEVICE_PATH)
>+ );
>+
>+ StrToIpv6Address (RemoteIPStr, NULL, &IPv6->RemoteIpAddress, NULL);
>+ IPv6->Protocol = (UINT16) NetworkProtocolFromText (ProtocolStr);
>+ if (StrCmp (TypeStr, L"Static") == 0) {
>+ IPv6->IpAddressOrigin = 0;
>+ } else if (StrCmp (TypeStr, L"StatelessAutoConfigure") == 0) {
>+ IPv6->IpAddressOrigin = 1;
>+ } else {
>+ IPv6->IpAddressOrigin = 2;
>+ }
>+
>+ StrToIpv6Address (LocalIPStr, NULL, &IPv6->LocalIpAddress, NULL);
>+ if (!IS_NULL (*GatewayIPStr) && !IS_NULL (*PrefixLengthStr)) {
>+ StrToIpv6Address (GatewayIPStr, NULL, &IPv6->GatewayIpAddress, NULL);
>+ IPv6->PrefixLength = (UINT8) Strtoi (PrefixLengthStr);
>+ } else {
>+ ZeroMem (&IPv6->GatewayIpAddress, sizeof (IPv6->GatewayIpAddress));
>+ IPv6->PrefixLength = 0;
>+ }
>+
>+ IPv6->LocalPort = 0;
>+ IPv6->RemotePort = 0;
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) IPv6;
>+}
>+
>+/**
>+ Converts a text device path node to UART device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created UART device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextUart (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *BaudStr;
>+ CHAR16 *DataBitsStr;
>+ CHAR16 *ParityStr;
>+ CHAR16 *StopBitsStr;
>+ UART_DEVICE_PATH *Uart;
>+
>+ BaudStr = GetNextParamStr (&TextDeviceNode);
>+ DataBitsStr = GetNextParamStr (&TextDeviceNode);
>+ ParityStr = GetNextParamStr (&TextDeviceNode);
>+ StopBitsStr = GetNextParamStr (&TextDeviceNode);
>+ Uart = (UART_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_UART_DP,
>+ (UINT16) sizeof (UART_DEVICE_PATH)
>+ );
>+
>+ if (StrCmp (BaudStr, L"DEFAULT") == 0) {
>+ Uart->BaudRate = 115200;
>+ } else {
>+ Strtoi64 (BaudStr, &Uart->BaudRate);
>+ }
>+ Uart->DataBits = (UINT8) ((StrCmp (DataBitsStr, L"DEFAULT") == 0) ? 8 :
>Strtoi (DataBitsStr));
>+ switch (*ParityStr) {
>+ case L'D':
>+ Uart->Parity = 0;
>+ break;
>+
>+ case L'N':
>+ Uart->Parity = 1;
>+ break;
>+
>+ case L'E':
>+ Uart->Parity = 2;
>+ break;
>+
>+ case L'O':
>+ Uart->Parity = 3;
>+ break;
>+
>+ case L'M':
>+ Uart->Parity = 4;
>+ break;
>+
>+ case L'S':
>+ Uart->Parity = 5;
>+ break;
>+
>+ default:
>+ Uart->Parity = (UINT8) Strtoi (ParityStr);
>+ break;
>+ }
>+
>+ if (StrCmp (StopBitsStr, L"D") == 0) {
>+ Uart->StopBits = (UINT8) 0;
>+ } else if (StrCmp (StopBitsStr, L"1") == 0) {
>+ Uart->StopBits = (UINT8) 1;
>+ } else if (StrCmp (StopBitsStr, L"1.5") == 0) {
>+ Uart->StopBits = (UINT8) 2;
>+ } else if (StrCmp (StopBitsStr, L"2") == 0) {
>+ Uart->StopBits = (UINT8) 3;
>+ } else {
>+ Uart->StopBits = (UINT8) Strtoi (StopBitsStr);
>+ }
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Uart;
>+}
>+
>+/**
>+ Converts a text device path node to USB class device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+ @param UsbClassText A pointer to USB_CLASS_TEXT structure to be
>integrated to USB Class Text.
>+
>+ @return A pointer to the newly-created USB class device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+ConvertFromTextUsbClass (
>+ CHAR16 *TextDeviceNode,
>+ USB_CLASS_TEXT *UsbClassText
>+ )
>+{
>+ CHAR16 *VIDStr;
>+ CHAR16 *PIDStr;
>+ CHAR16 *ClassStr;
>+ CHAR16 *SubClassStr;
>+ CHAR16 *ProtocolStr;
>+ USB_CLASS_DEVICE_PATH *UsbClass;
>+
>+ UsbClass = (USB_CLASS_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_USB_CLASS_DP,
>+ (UINT16) sizeof (USB_CLASS_DEVICE_PATH)
>+ );
>+
>+ VIDStr = GetNextParamStr (&TextDeviceNode);
>+ PIDStr = GetNextParamStr (&TextDeviceNode);
>+ if (UsbClassText->ClassExist) {
>+ ClassStr = GetNextParamStr (&TextDeviceNode);
>+ UsbClass->DeviceClass = (UINT8) Strtoi (ClassStr);
>+ } else {
>+ UsbClass->DeviceClass = UsbClassText->Class;
>+ }
>+ if (UsbClassText->SubClassExist) {
>+ SubClassStr = GetNextParamStr (&TextDeviceNode);
>+ UsbClass->DeviceSubClass = (UINT8) Strtoi (SubClassStr);
>+ } else {
>+ UsbClass->DeviceSubClass = UsbClassText->SubClass;
>+ }
>+
>+ ProtocolStr = GetNextParamStr (&TextDeviceNode);
>+
>+ UsbClass->VendorId = (UINT16) Strtoi (VIDStr);
>+ UsbClass->ProductId = (UINT16) Strtoi (PIDStr);
>+ UsbClass->DeviceProtocol = (UINT8) Strtoi (ProtocolStr);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) UsbClass;
>+}
>+
>+
>+/**
>+ Converts a text device path node to USB class device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created USB class device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextUsbClass (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ USB_CLASS_TEXT UsbClassText;
>+
>+ UsbClassText.ClassExist = TRUE;
>+ UsbClassText.SubClassExist = TRUE;
>+
>+ return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
>+}
>+
>+/**
>+ Converts a text device path node to USB audio device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created USB audio device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextUsbAudio (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ USB_CLASS_TEXT UsbClassText;
>+
>+ UsbClassText.ClassExist = FALSE;
>+ UsbClassText.Class = USB_CLASS_AUDIO;
>+ UsbClassText.SubClassExist = TRUE;
>+
>+ return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
>+}
>+
>+/**
>+ Converts a text device path node to USB CDC Control device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created USB CDC Control device path
>structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextUsbCDCControl (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ USB_CLASS_TEXT UsbClassText;
>+
>+ UsbClassText.ClassExist = FALSE;
>+ UsbClassText.Class = USB_CLASS_CDCCONTROL;
>+ UsbClassText.SubClassExist = TRUE;
>+
>+ return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
>+}
>+
>+/**
>+ Converts a text device path node to USB HID device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created USB HID device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextUsbHID (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ USB_CLASS_TEXT UsbClassText;
>+
>+ UsbClassText.ClassExist = FALSE;
>+ UsbClassText.Class = USB_CLASS_HID;
>+ UsbClassText.SubClassExist = TRUE;
>+
>+ return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
>+}
>+
>+/**
>+ Converts a text device path node to USB Image device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created USB Image device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextUsbImage (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ USB_CLASS_TEXT UsbClassText;
>+
>+ UsbClassText.ClassExist = FALSE;
>+ UsbClassText.Class = USB_CLASS_IMAGE;
>+ UsbClassText.SubClassExist = TRUE;
>+
>+ return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
>+}
>+
>+/**
>+ Converts a text device path node to USB Print device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created USB Print device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextUsbPrinter (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ USB_CLASS_TEXT UsbClassText;
>+
>+ UsbClassText.ClassExist = FALSE;
>+ UsbClassText.Class = USB_CLASS_PRINTER;
>+ UsbClassText.SubClassExist = TRUE;
>+
>+ return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
>+}
>+
>+/**
>+ Converts a text device path node to USB mass storage device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created USB mass storage device path
>structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextUsbMassStorage (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ USB_CLASS_TEXT UsbClassText;
>+
>+ UsbClassText.ClassExist = FALSE;
>+ UsbClassText.Class = USB_CLASS_MASS_STORAGE;
>+ UsbClassText.SubClassExist = TRUE;
>+
>+ return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
>+}
>+
>+/**
>+ Converts a text device path node to USB HUB device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created USB HUB device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextUsbHub (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ USB_CLASS_TEXT UsbClassText;
>+
>+ UsbClassText.ClassExist = FALSE;
>+ UsbClassText.Class = USB_CLASS_HUB;
>+ UsbClassText.SubClassExist = TRUE;
>+
>+ return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
>+}
>+
>+/**
>+ Converts a text device path node to USB CDC data device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created USB CDC data device path
>structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextUsbCDCData (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ USB_CLASS_TEXT UsbClassText;
>+
>+ UsbClassText.ClassExist = FALSE;
>+ UsbClassText.Class = USB_CLASS_CDCDATA;
>+ UsbClassText.SubClassExist = TRUE;
>+
>+ return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
>+}
>+
>+/**
>+ Converts a text device path node to USB smart card device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created USB smart card device path
>structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextUsbSmartCard (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ USB_CLASS_TEXT UsbClassText;
>+
>+ UsbClassText.ClassExist = FALSE;
>+ UsbClassText.Class = USB_CLASS_SMART_CARD;
>+ UsbClassText.SubClassExist = TRUE;
>+
>+ return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
>+}
>+
>+/**
>+ Converts a text device path node to USB video device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created USB video device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextUsbVideo (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ USB_CLASS_TEXT UsbClassText;
>+
>+ UsbClassText.ClassExist = FALSE;
>+ UsbClassText.Class = USB_CLASS_VIDEO;
>+ UsbClassText.SubClassExist = TRUE;
>+
>+ return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
>+}
>+
>+/**
>+ Converts a text device path node to USB diagnostic device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created USB diagnostic device path
>structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextUsbDiagnostic (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ USB_CLASS_TEXT UsbClassText;
>+
>+ UsbClassText.ClassExist = FALSE;
>+ UsbClassText.Class = USB_CLASS_DIAGNOSTIC;
>+ UsbClassText.SubClassExist = TRUE;
>+
>+ return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
>+}
>+
>+/**
>+ Converts a text device path node to USB wireless device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created USB wireless device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextUsbWireless (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ USB_CLASS_TEXT UsbClassText;
>+
>+ UsbClassText.ClassExist = FALSE;
>+ UsbClassText.Class = USB_CLASS_WIRELESS;
>+ UsbClassText.SubClassExist = TRUE;
>+
>+ return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
>+}
>+
>+/**
>+ Converts a text device path node to USB device firmware update device
>path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created USB device firmware update
>device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextUsbDeviceFirmwareUpdate (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ USB_CLASS_TEXT UsbClassText;
>+
>+ UsbClassText.ClassExist = FALSE;
>+ UsbClassText.Class = USB_CLASS_RESERVE;
>+ UsbClassText.SubClassExist = FALSE;
>+ UsbClassText.SubClass = USB_SUBCLASS_FW_UPDATE;
>+
>+ return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
>+}
>+
>+/**
>+ Converts a text device path node to USB IRDA bridge device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created USB IRDA bridge device path
>structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextUsbIrdaBridge (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ USB_CLASS_TEXT UsbClassText;
>+
>+ UsbClassText.ClassExist = FALSE;
>+ UsbClassText.Class = USB_CLASS_RESERVE;
>+ UsbClassText.SubClassExist = FALSE;
>+ UsbClassText.SubClass = USB_SUBCLASS_IRDA_BRIDGE;
>+
>+ return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
>+}
>+
>+/**
>+ Converts a text device path node to USB text and measurement device
>path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created USB text and measurement device
>path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextUsbTestAndMeasurement (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ USB_CLASS_TEXT UsbClassText;
>+
>+ UsbClassText.ClassExist = FALSE;
>+ UsbClassText.Class = USB_CLASS_RESERVE;
>+ UsbClassText.SubClassExist = FALSE;
>+ UsbClassText.SubClass = USB_SUBCLASS_TEST;
>+
>+ return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
>+}
>+
>+/**
>+ Converts a text device path node to USB WWID device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created USB WWID device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextUsbWwid (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *VIDStr;
>+ CHAR16 *PIDStr;
>+ CHAR16 *InterfaceNumStr;
>+ CHAR16 *SerialNumberStr;
>+ USB_WWID_DEVICE_PATH *UsbWwid;
>+ UINTN SerialNumberStrLen;
>+
>+ VIDStr = GetNextParamStr (&TextDeviceNode);
>+ PIDStr = GetNextParamStr (&TextDeviceNode);
>+ InterfaceNumStr = GetNextParamStr (&TextDeviceNode);
>+ SerialNumberStr = GetNextParamStr (&TextDeviceNode);
>+ SerialNumberStrLen = StrLen (SerialNumberStr);
>+ if (SerialNumberStrLen >= 2 &&
>+ SerialNumberStr[0] == L'\"' &&
>+ SerialNumberStr[SerialNumberStrLen - 1] == L'\"'
>+ ) {
>+ SerialNumberStr[SerialNumberStrLen - 1] = L'\0';
>+ SerialNumberStr++;
>+ SerialNumberStrLen -= 2;
>+ }
>+ UsbWwid = (USB_WWID_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_USB_WWID_DP,
>+ (UINT16) (sizeof (USB_WWID_DEVICE_PATH) +
>SerialNumberStrLen * sizeof (CHAR16))
>+ );
>+ UsbWwid->VendorId = (UINT16) Strtoi (VIDStr);
>+ UsbWwid->ProductId = (UINT16) Strtoi (PIDStr);
>+ UsbWwid->InterfaceNumber = (UINT16) Strtoi (InterfaceNumStr);
>+
>+ //
>+ // There is no memory allocated in UsbWwid for the '\0' in SerialNumberStr.
>+ // Therefore, the '\0' will not be copied.
>+ //
>+ memcpy (
>+ (UINT8 *) UsbWwid + sizeof (USB_WWID_DEVICE_PATH),
>+ SerialNumberStr,
>+ SerialNumberStrLen * sizeof (CHAR16)
>+ );
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) UsbWwid;
>+}
>+
>+/**
>+ Converts a text device path node to Logic Unit device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created Logic Unit device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextUnit (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *LunStr;
>+ DEVICE_LOGICAL_UNIT_DEVICE_PATH *LogicalUnit;
>+
>+ LunStr = GetNextParamStr (&TextDeviceNode);
>+ LogicalUnit = (DEVICE_LOGICAL_UNIT_DEVICE_PATH *) CreateDeviceNode
>(
>+ MESSAGING_DEVICE_PATH,
>+ MSG_DEVICE_LOGICAL_UNIT_DP,
>+ (UINT16) sizeof
>(DEVICE_LOGICAL_UNIT_DEVICE_PATH)
>+ );
>+
>+ LogicalUnit->Lun = (UINT8) Strtoi (LunStr);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) LogicalUnit;
>+}
>+
>+/**
>+ Converts a text device path node to iSCSI device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created iSCSI device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextiSCSI (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ UINT16 Options;
>+ CHAR16 *NameStr;
>+ CHAR16 *PortalGroupStr;
>+ CHAR16 *LunStr;
>+ CHAR16 *HeaderDigestStr;
>+ CHAR16 *DataDigestStr;
>+ CHAR16 *AuthenticationStr;
>+ CHAR16 *ProtocolStr;
>+ CHAR8 *AsciiStr;
>+ ISCSI_DEVICE_PATH_WITH_NAME *ISCSIDevPath;
>+
>+ NameStr = GetNextParamStr (&TextDeviceNode);
>+ PortalGroupStr = GetNextParamStr (&TextDeviceNode);
>+ LunStr = GetNextParamStr (&TextDeviceNode);
>+ HeaderDigestStr = GetNextParamStr (&TextDeviceNode);
>+ DataDigestStr = GetNextParamStr (&TextDeviceNode);
>+ AuthenticationStr = GetNextParamStr (&TextDeviceNode);
>+ ProtocolStr = GetNextParamStr (&TextDeviceNode);
>+ ISCSIDevPath = (ISCSI_DEVICE_PATH_WITH_NAME *) CreateDeviceNode
>(
>+ MESSAGING_DEVICE_PATH,
>+ MSG_ISCSI_DP,
>+ (UINT16) (sizeof
>(ISCSI_DEVICE_PATH_WITH_NAME) + StrLen (NameStr))
>+ );
>+
>+ AsciiStr = ISCSIDevPath->TargetName;
>+ StrToAscii (NameStr, &AsciiStr);
>+
>+ ISCSIDevPath->TargetPortalGroupTag = (UINT16) Strtoi (PortalGroupStr);
>+ Strtoi64 (LunStr, &ISCSIDevPath->Lun);
>+
>+ Options = 0x0000;
>+ if (StrCmp (HeaderDigestStr, L"CRC32C") == 0) {
>+ Options |= 0x0002;
>+ }
>+
>+ if (StrCmp (DataDigestStr, L"CRC32C") == 0) {
>+ Options |= 0x0008;
>+ }
>+
>+ if (StrCmp (AuthenticationStr, L"None") == 0) {
>+ Options |= 0x0800;
>+ }
>+
>+ if (StrCmp (AuthenticationStr, L"CHAP_UNI") == 0) {
>+ Options |= 0x1000;
>+ }
>+
>+ ISCSIDevPath->LoginOption = (UINT16) Options;
>+
>+ if (StrCmp (ProtocolStr, L"TCP") == 0) {
>+ ISCSIDevPath->NetworkProtocol = 0;
>+ } else {
>+ //
>+ // Undefined and reserved.
>+ //
>+ ISCSIDevPath->NetworkProtocol = 1;
>+ }
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) ISCSIDevPath;
>+}
>+
>+/**
>+ Converts a text device path node to VLAN device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created VLAN device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextVlan (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *VlanStr;
>+ VLAN_DEVICE_PATH *Vlan;
>+
>+ VlanStr = GetNextParamStr (&TextDeviceNode);
>+ Vlan = (VLAN_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_VLAN_DP,
>+ (UINT16) sizeof (VLAN_DEVICE_PATH)
>+ );
>+
>+ Vlan->VlanId = (UINT16) Strtoi (VlanStr);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Vlan;
>+}
>+
>+/**
>+ Converts a text device path node to Bluetooth device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created Bluetooth device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextBluetooth (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *BluetoothStr;
>+ BLUETOOTH_DEVICE_PATH *BluetoothDp;
>+
>+ BluetoothStr = GetNextParamStr (&TextDeviceNode);
>+ BluetoothDp = (BLUETOOTH_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_BLUETOOTH_DP,
>+ (UINT16) sizeof (BLUETOOTH_DEVICE_PATH)
>+ );
>+ StrHexToBytes (
>+ BluetoothStr,
>+ sizeof (BLUETOOTH_ADDRESS) * 2,
>+ BluetoothDp->BD_ADDR.Address,
>+ sizeof (BLUETOOTH_ADDRESS)
>+ );
>+ return (EFI_DEVICE_PATH_PROTOCOL *) BluetoothDp;
>+}
>+
>+/**
>+ Converts a text device path node to Wi-Fi device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created Wi-Fi device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextWiFi (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *SSIdStr;
>+ CHAR8 AsciiStr[33];
>+ UINTN DataLen;
>+ WIFI_DEVICE_PATH *WiFiDp;
>+
>+ SSIdStr = GetNextParamStr (&TextDeviceNode);
>+ WiFiDp = (WIFI_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_WIFI_DP,
>+ (UINT16) sizeof (WIFI_DEVICE_PATH)
>+ );
>+
>+ if (NULL != SSIdStr) {
>+ DataLen = StrLen (SSIdStr);
>+ if (StrLen (SSIdStr) > 32) {
>+ SSIdStr[32] = L'\0';
>+ DataLen = 32;
>+ }
>+
>+ UnicodeStrToAsciiStrS (SSIdStr, AsciiStr, sizeof (AsciiStr));
>+ memcpy (WiFiDp->SSId, AsciiStr, DataLen);
>+ }
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) WiFiDp;
>+}
>+
>+/**
>+ Converts a text device path node to URI device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created URI device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextUri (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *UriStr;
>+ UINTN UriLength;
>+ URI_DEVICE_PATH *Uri;
>+
>+ UriStr = GetNextParamStr (&TextDeviceNode);
>+ UriLength = StrnLenS (UriStr, MAX_UINT16 - sizeof (URI_DEVICE_PATH));
>+ Uri = (URI_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_URI_DP,
>+ (UINT16) (sizeof (URI_DEVICE_PATH) + UriLength)
>+ );
>+
>+ while (UriLength-- != 0) {
>+ Uri->Uri[UriLength] = (CHAR8) UriStr[UriLength];
>+ }
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Uri;
>+}
>+
>+/**
>+ Converts a media text device path node to media device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to media device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextMediaPath (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ return DevPathFromTextGenericPath (MEDIA_DEVICE_PATH,
>TextDeviceNode);
>+}
>+
>+/**
>+ Converts a text device path node to HD device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created HD device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextHD (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *PartitionStr;
>+ CHAR16 *TypeStr;
>+ CHAR16 *SignatureStr;
>+ CHAR16 *StartStr;
>+ CHAR16 *SizeStr;
>+ UINT32 Signature32;
>+ HARDDRIVE_DEVICE_PATH *Hd;
>+
>+ PartitionStr = GetNextParamStr (&TextDeviceNode);
>+ TypeStr = GetNextParamStr (&TextDeviceNode);
>+ SignatureStr = GetNextParamStr (&TextDeviceNode);
>+ StartStr = GetNextParamStr (&TextDeviceNode);
>+ SizeStr = GetNextParamStr (&TextDeviceNode);
>+ Hd = (HARDDRIVE_DEVICE_PATH *) CreateDeviceNode (
>+ MEDIA_DEVICE_PATH,
>+ MEDIA_HARDDRIVE_DP,
>+ (UINT16) sizeof (HARDDRIVE_DEVICE_PATH)
>+ );
>+
>+ Hd->PartitionNumber = (UINT32) Strtoi (PartitionStr);
>+
>+ ZeroMem (Hd->Signature, 16);
>+ Hd->MBRType = (UINT8) 0;
>+
>+ if (StrCmp (TypeStr, L"MBR") == 0) {
>+ Hd->SignatureType = SIGNATURE_TYPE_MBR;
>+ Hd->MBRType = 0x01;
>+
>+ Signature32 = (UINT32) Strtoi (SignatureStr);
>+ memcpy (Hd->Signature, &Signature32, sizeof (UINT32));
>+ } else if (StrCmp (TypeStr, L"GPT") == 0) {
>+ Hd->SignatureType = SIGNATURE_TYPE_GUID;
>+ Hd->MBRType = 0x02;
>+
>+ StrToGuid (SignatureStr, (EFI_GUID *) Hd->Signature);
>+ } else {
>+ Hd->SignatureType = (UINT8) Strtoi (TypeStr);
>+ }
>+
>+ Strtoi64 (StartStr, &Hd->PartitionStart);
>+ Strtoi64 (SizeStr, &Hd->PartitionSize);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Hd;
>+}
>+
>+/**
>+ Converts a text device path node to CDROM device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created CDROM device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextCDROM (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *EntryStr;
>+ CHAR16 *StartStr;
>+ CHAR16 *SizeStr;
>+ CDROM_DEVICE_PATH *CDROMDevPath;
>+
>+ EntryStr = GetNextParamStr (&TextDeviceNode);
>+ StartStr = GetNextParamStr (&TextDeviceNode);
>+ SizeStr = GetNextParamStr (&TextDeviceNode);
>+ CDROMDevPath = (CDROM_DEVICE_PATH *) CreateDeviceNode (
>+ MEDIA_DEVICE_PATH,
>+ MEDIA_CDROM_DP,
>+ (UINT16) sizeof (CDROM_DEVICE_PATH)
>+ );
>+
>+ CDROMDevPath->BootEntry = (UINT32) Strtoi (EntryStr);
>+ Strtoi64 (StartStr, &CDROMDevPath->PartitionStart);
>+ Strtoi64 (SizeStr, &CDROMDevPath->PartitionSize);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) CDROMDevPath;
>+}
>+
>+/**
>+ Converts a text device path node to Vendor-defined media device path
>structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created Vendor-defined media device path
>structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextVenMedia (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ return ConvertFromTextVendor (
>+ TextDeviceNode,
>+ MEDIA_DEVICE_PATH,
>+ MEDIA_VENDOR_DP
>+ );
>+}
>+
>+/**
>+ Converts a text device path node to File device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created File device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextFilePath (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ FILEPATH_DEVICE_PATH *File;
>+
>+ File = (FILEPATH_DEVICE_PATH *) CreateDeviceNode (
>+ MEDIA_DEVICE_PATH,
>+ MEDIA_FILEPATH_DP,
>+ (UINT16) (sizeof (FILEPATH_DEVICE_PATH) + StrLen
>(TextDeviceNode) * 2)
>+ );
>+
>+ StrCpyS (File->PathName, StrLen (TextDeviceNode) + 1, TextDeviceNode);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) File;
>+}
>+
>+/**
>+ Converts a text device path node to Media protocol device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created Media protocol device path
>structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextMedia (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *GuidStr;
>+ MEDIA_PROTOCOL_DEVICE_PATH *Media;
>+
>+ GuidStr = GetNextParamStr (&TextDeviceNode);
>+ Media = (MEDIA_PROTOCOL_DEVICE_PATH *) CreateDeviceNode (
>+ MEDIA_DEVICE_PATH,
>+ MEDIA_PROTOCOL_DP,
>+ (UINT16) sizeof (MEDIA_PROTOCOL_DEVICE_PATH)
>+ );
>+
>+ StrToGuid (GuidStr, &Media->Protocol);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Media;
>+}
>+
>+/**
>+ Converts a text device path node to firmware volume device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created firmware volume device path
>structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextFv (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *GuidStr;
>+ MEDIA_FW_VOL_DEVICE_PATH *Fv;
>+
>+ GuidStr = GetNextParamStr (&TextDeviceNode);
>+ Fv = (MEDIA_FW_VOL_DEVICE_PATH *) CreateDeviceNode (
>+ MEDIA_DEVICE_PATH,
>+ MEDIA_PIWG_FW_VOL_DP,
>+ (UINT16) sizeof (MEDIA_FW_VOL_DEVICE_PATH)
>+ );
>+
>+ StrToGuid (GuidStr, &Fv->FvName);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Fv;
>+}
>+
>+/**
>+ Converts a text device path node to firmware file device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created firmware file device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextFvFile (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *GuidStr;
>+ MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *FvFile;
>+
>+ GuidStr = GetNextParamStr (&TextDeviceNode);
>+ FvFile = (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) CreateDeviceNode (
>+ MEDIA_DEVICE_PATH,
>+ MEDIA_PIWG_FW_FILE_DP,
>+ (UINT16) sizeof
>(MEDIA_FW_VOL_FILEPATH_DEVICE_PATH)
>+ );
>+
>+ StrToGuid (GuidStr, &FvFile->FvFileName);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) FvFile;
>+}
>+
>+/**
>+ Converts a text device path node to text relative offset device path
>structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created Text device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextRelativeOffsetRange (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *StartingOffsetStr;
>+ CHAR16 *EndingOffsetStr;
>+ MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH *Offset;
>+
>+ StartingOffsetStr = GetNextParamStr (&TextDeviceNode);
>+ EndingOffsetStr = GetNextParamStr (&TextDeviceNode);
>+ Offset = (MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH *)
>CreateDeviceNode (
>+ MEDIA_DEVICE_PATH,
>+ MEDIA_RELATIVE_OFFSET_RANGE_DP,
>+ (UINT16) sizeof
>(MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH)
>+ );
>+
>+ Strtoi64 (StartingOffsetStr, &Offset->StartingOffset);
>+ Strtoi64 (EndingOffsetStr, &Offset->EndingOffset);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Offset;
>+}
>+
>+/**
>+ Converts a text device path node to text ram disk device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created Text device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextRamDisk (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *StartingAddrStr;
>+ CHAR16 *EndingAddrStr;
>+ CHAR16 *TypeGuidStr;
>+ CHAR16 *InstanceStr;
>+ MEDIA_RAM_DISK_DEVICE_PATH *RamDisk;
>+ UINT64 StartingAddr;
>+ UINT64 EndingAddr;
>+
>+ StartingAddrStr = GetNextParamStr (&TextDeviceNode);
>+ EndingAddrStr = GetNextParamStr (&TextDeviceNode);
>+ InstanceStr = GetNextParamStr (&TextDeviceNode);
>+ TypeGuidStr = GetNextParamStr (&TextDeviceNode);
>+ RamDisk = (MEDIA_RAM_DISK_DEVICE_PATH *) CreateDeviceNode (
>+ MEDIA_DEVICE_PATH,
>+ MEDIA_RAM_DISK_DP,
>+ (UINT16) sizeof
>(MEDIA_RAM_DISK_DEVICE_PATH)
>+ );
>+
>+ Strtoi64 (StartingAddrStr, &StartingAddr);
>+ WriteUnaligned64 ((UINT64 *) &(RamDisk->StartingAddr[0]), StartingAddr);
>+ Strtoi64 (EndingAddrStr, &EndingAddr);
>+ WriteUnaligned64 ((UINT64 *) &(RamDisk->EndingAddr[0]), EndingAddr);
>+ RamDisk->Instance = (UINT16) Strtoi (InstanceStr);
>+ StrToGuid (TypeGuidStr, &RamDisk->TypeGuid);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) RamDisk;
>+}
>+
>+/**
>+ Converts a text device path node to text virtual disk device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created Text device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextVirtualDisk (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *StartingAddrStr;
>+ CHAR16 *EndingAddrStr;
>+ CHAR16 *InstanceStr;
>+ MEDIA_RAM_DISK_DEVICE_PATH *RamDisk;
>+ UINT64 StartingAddr;
>+ UINT64 EndingAddr;
>+
>+ StartingAddrStr = GetNextParamStr (&TextDeviceNode);
>+ EndingAddrStr = GetNextParamStr (&TextDeviceNode);
>+ InstanceStr = GetNextParamStr (&TextDeviceNode);
>+
>+ RamDisk = (MEDIA_RAM_DISK_DEVICE_PATH *) CreateDeviceNode (
>+ MEDIA_DEVICE_PATH,
>+ MEDIA_RAM_DISK_DP,
>+ (UINT16) sizeof
>(MEDIA_RAM_DISK_DEVICE_PATH)
>+ );
>+
>+ Strtoi64 (StartingAddrStr, &StartingAddr);
>+ WriteUnaligned64 ((UINT64 *) &(RamDisk->StartingAddr[0]), StartingAddr);
>+ Strtoi64 (EndingAddrStr, &EndingAddr);
>+ WriteUnaligned64 ((UINT64 *) &(RamDisk->EndingAddr[0]), EndingAddr);
>+ RamDisk->Instance = (UINT16) Strtoi (InstanceStr);
>+ CopyGuid (&RamDisk->TypeGuid, &gEfiVirtualDiskGuid);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) RamDisk;
>+}
>+
>+/**
>+ Converts a text device path node to text virtual cd device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created Text device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextVirtualCd (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *StartingAddrStr;
>+ CHAR16 *EndingAddrStr;
>+ CHAR16 *InstanceStr;
>+ MEDIA_RAM_DISK_DEVICE_PATH *RamDisk;
>+ UINT64 StartingAddr;
>+ UINT64 EndingAddr;
>+
>+ StartingAddrStr = GetNextParamStr (&TextDeviceNode);
>+ EndingAddrStr = GetNextParamStr (&TextDeviceNode);
>+ InstanceStr = GetNextParamStr (&TextDeviceNode);
>+
>+ RamDisk = (MEDIA_RAM_DISK_DEVICE_PATH *) CreateDeviceNode (
>+ MEDIA_DEVICE_PATH,
>+ MEDIA_RAM_DISK_DP,
>+ (UINT16) sizeof
>(MEDIA_RAM_DISK_DEVICE_PATH)
>+ );
>+
>+ Strtoi64 (StartingAddrStr, &StartingAddr);
>+ WriteUnaligned64 ((UINT64 *) &(RamDisk->StartingAddr[0]), StartingAddr);
>+ Strtoi64 (EndingAddrStr, &EndingAddr);
>+ WriteUnaligned64 ((UINT64 *) &(RamDisk->EndingAddr[0]), EndingAddr);
>+ RamDisk->Instance = (UINT16) Strtoi (InstanceStr);
>+ CopyGuid (&RamDisk->TypeGuid, &gEfiVirtualCdGuid);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) RamDisk;
>+}
>+
>+/**
>+ Converts a text device path node to text persistent virtual disk device path
>structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created Text device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextPersistentVirtualDisk (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *StartingAddrStr;
>+ CHAR16 *EndingAddrStr;
>+ CHAR16 *InstanceStr;
>+ MEDIA_RAM_DISK_DEVICE_PATH *RamDisk;
>+ UINT64 StartingAddr;
>+ UINT64 EndingAddr;
>+
>+ StartingAddrStr = GetNextParamStr (&TextDeviceNode);
>+ EndingAddrStr = GetNextParamStr (&TextDeviceNode);
>+ InstanceStr = GetNextParamStr (&TextDeviceNode);
>+
>+ RamDisk = (MEDIA_RAM_DISK_DEVICE_PATH *) CreateDeviceNode (
>+ MEDIA_DEVICE_PATH,
>+ MEDIA_RAM_DISK_DP,
>+ (UINT16) sizeof
>(MEDIA_RAM_DISK_DEVICE_PATH)
>+ );
>+
>+ Strtoi64 (StartingAddrStr, &StartingAddr);
>+ WriteUnaligned64 ((UINT64 *) &(RamDisk->StartingAddr[0]), StartingAddr);
>+ Strtoi64 (EndingAddrStr, &EndingAddr);
>+ WriteUnaligned64 ((UINT64 *) &(RamDisk->EndingAddr[0]), EndingAddr);
>+ RamDisk->Instance = (UINT16) Strtoi (InstanceStr);
>+ CopyGuid (&RamDisk->TypeGuid, &gEfiPersistentVirtualDiskGuid);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) RamDisk;
>+}
>+
>+/**
>+ Converts a text device path node to text persistent virtual cd device path
>structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created Text device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextPersistentVirtualCd (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *StartingAddrStr;
>+ CHAR16 *EndingAddrStr;
>+ CHAR16 *InstanceStr;
>+ MEDIA_RAM_DISK_DEVICE_PATH *RamDisk;
>+ UINT64 StartingAddr;
>+ UINT64 EndingAddr;
>+
>+ StartingAddrStr = GetNextParamStr (&TextDeviceNode);
>+ EndingAddrStr = GetNextParamStr (&TextDeviceNode);
>+ InstanceStr = GetNextParamStr (&TextDeviceNode);
>+
>+ RamDisk = (MEDIA_RAM_DISK_DEVICE_PATH *) CreateDeviceNode (
>+ MEDIA_DEVICE_PATH,
>+ MEDIA_RAM_DISK_DP,
>+ (UINT16) sizeof
>(MEDIA_RAM_DISK_DEVICE_PATH)
>+ );
>+
>+ Strtoi64 (StartingAddrStr, &StartingAddr);
>+ WriteUnaligned64 ((UINT64 *) &(RamDisk->StartingAddr[0]), StartingAddr);
>+ Strtoi64 (EndingAddrStr, &EndingAddr);
>+ WriteUnaligned64 ((UINT64 *) &(RamDisk->EndingAddr[0]), EndingAddr);
>+ RamDisk->Instance = (UINT16) Strtoi (InstanceStr);
>+ CopyGuid (&RamDisk->TypeGuid, &gEfiPersistentVirtualCdGuid);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) RamDisk;
>+}
>+
>+/**
>+ Converts a BBS text device path node to BBS device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to BBS device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextBbsPath (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ return DevPathFromTextGenericPath (BBS_DEVICE_PATH,
>TextDeviceNode);
>+}
>+
>+/**
>+ Converts a text device path node to BIOS Boot Specification device path
>structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created BIOS Boot Specification device path
>structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextBBS (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ CHAR16 *TypeStr;
>+ CHAR16 *IdStr;
>+ CHAR16 *FlagsStr;
>+ CHAR8 *AsciiStr;
>+ BBS_BBS_DEVICE_PATH *Bbs;
>+
>+ TypeStr = GetNextParamStr (&TextDeviceNode);
>+ IdStr = GetNextParamStr (&TextDeviceNode);
>+ FlagsStr = GetNextParamStr (&TextDeviceNode);
>+ Bbs = (BBS_BBS_DEVICE_PATH *) CreateDeviceNode (
>+ BBS_DEVICE_PATH,
>+ BBS_BBS_DP,
>+ (UINT16) (sizeof (BBS_BBS_DEVICE_PATH) + StrLen
>(IdStr))
>+ );
>+
>+ if (StrCmp (TypeStr, L"Floppy") == 0) {
>+ Bbs->DeviceType = BBS_TYPE_FLOPPY;
>+ } else if (StrCmp (TypeStr, L"HD") == 0) {
>+ Bbs->DeviceType = BBS_TYPE_HARDDRIVE;
>+ } else if (StrCmp (TypeStr, L"CDROM") == 0) {
>+ Bbs->DeviceType = BBS_TYPE_CDROM;
>+ } else if (StrCmp (TypeStr, L"PCMCIA") == 0) {
>+ Bbs->DeviceType = BBS_TYPE_PCMCIA;
>+ } else if (StrCmp (TypeStr, L"USB") == 0) {
>+ Bbs->DeviceType = BBS_TYPE_USB;
>+ } else if (StrCmp (TypeStr, L"Network") == 0) {
>+ Bbs->DeviceType = BBS_TYPE_EMBEDDED_NETWORK;
>+ } else {
>+ Bbs->DeviceType = (UINT16) Strtoi (TypeStr);
>+ }
>+
>+ AsciiStr = Bbs->String;
>+ StrToAscii (IdStr, &AsciiStr);
>+
>+ Bbs->StatusFlag = (UINT16) Strtoi (FlagsStr);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Bbs;
>+}
>+
>+/**
>+ Converts a text device path node to SATA device path structure.
>+
>+ @param TextDeviceNode The input Text device path node.
>+
>+ @return A pointer to the newly-created SATA device path structure.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevPathFromTextSata (
>+ CHAR16 *TextDeviceNode
>+ )
>+{
>+ SATA_DEVICE_PATH *Sata;
>+ CHAR16 *Param1;
>+ CHAR16 *Param2;
>+ CHAR16 *Param3;
>+
>+ Param1 = GetNextParamStr (&TextDeviceNode);
>+ Param2 = GetNextParamStr (&TextDeviceNode);
>+ Param3 = GetNextParamStr (&TextDeviceNode);
>+
>+ Sata = (SATA_DEVICE_PATH *) CreateDeviceNode (
>+ MESSAGING_DEVICE_PATH,
>+ MSG_SATA_DP,
>+ (UINT16) sizeof (SATA_DEVICE_PATH)
>+ );
>+ Sata->HBAPortNumber = (UINT16) Strtoi (Param1);
>+ Sata->PortMultiplierPortNumber = (UINT16) Strtoi (Param2);
>+ Sata->Lun = (UINT16) Strtoi (Param3);
>+
>+ return (EFI_DEVICE_PATH_PROTOCOL *) Sata;
>+}
>+
>+DEVICE_PATH_FROM_TEXT_TABLE
>mUefiDevicePathLibDevPathFromTextTable[] = {
>+ {L"Path", DevPathFromTextPath },
>+
>+ {L"HardwarePath", DevPathFromTextHardwarePath },
>+ {L"Pci", DevPathFromTextPci },
>+ {L"PcCard", DevPathFromTextPcCard },
>+ {L"MemoryMapped", DevPathFromTextMemoryMapped },
>+ {L"VenHw", DevPathFromTextVenHw },
>+ {L"Ctrl", DevPathFromTextCtrl },
>+ {L"BMC", DevPathFromTextBmc },
>+
>+ {L"AcpiPath", DevPathFromTextAcpiPath },
>+ {L"Acpi", DevPathFromTextAcpi },
>+ {L"PciRoot", DevPathFromTextPciRoot },
>+ {L"PcieRoot", DevPathFromTextPcieRoot },
>+ {L"Floppy", DevPathFromTextFloppy },
>+ {L"Keyboard", DevPathFromTextKeyboard },
>+ {L"Serial", DevPathFromTextSerial },
>+ {L"ParallelPort", DevPathFromTextParallelPort },
>+ {L"AcpiEx", DevPathFromTextAcpiEx },
>+ {L"AcpiExp", DevPathFromTextAcpiExp },
>+ {L"AcpiAdr", DevPathFromTextAcpiAdr },
>+
>+ {L"Msg", DevPathFromTextMsg },
>+ {L"Ata", DevPathFromTextAta },
>+ {L"Scsi", DevPathFromTextScsi },
>+ {L"Fibre", DevPathFromTextFibre },
>+ {L"FibreEx", DevPathFromTextFibreEx },
>+ {L"I1394", DevPathFromText1394 },
>+ {L"USB", DevPathFromTextUsb },
>+ {L"I2O", DevPathFromTextI2O },
>+ {L"Infiniband", DevPathFromTextInfiniband },
>+ {L"VenMsg", DevPathFromTextVenMsg },
>+ {L"VenPcAnsi", DevPathFromTextVenPcAnsi },
>+ {L"VenVt100", DevPathFromTextVenVt100 },
>+ {L"VenVt100Plus", DevPathFromTextVenVt100Plus },
>+ {L"VenUtf8", DevPathFromTextVenUtf8 },
>+ {L"UartFlowCtrl", DevPathFromTextUartFlowCtrl },
>+ {L"SAS", DevPathFromTextSAS },
>+ {L"SasEx", DevPathFromTextSasEx },
>+ {L"NVMe", DevPathFromTextNVMe },
>+ {L"UFS", DevPathFromTextUfs },
>+ {L"SD", DevPathFromTextSd },
>+ {L"eMMC", DevPathFromTextEmmc },
>+ {L"DebugPort", DevPathFromTextDebugPort },
>+ {L"MAC", DevPathFromTextMAC },
>+ {L"IPv4", DevPathFromTextIPv4 },
>+ {L"IPv6", DevPathFromTextIPv6 },
>+ {L"Uart", DevPathFromTextUart },
>+ {L"UsbClass", DevPathFromTextUsbClass },
>+ {L"UsbAudio", DevPathFromTextUsbAudio },
>+ {L"UsbCDCControl", DevPathFromTextUsbCDCControl },
>+ {L"UsbHID", DevPathFromTextUsbHID },
>+ {L"UsbImage", DevPathFromTextUsbImage },
>+ {L"UsbPrinter", DevPathFromTextUsbPrinter },
>+ {L"UsbMassStorage", DevPathFromTextUsbMassStorage },
>+ {L"UsbHub", DevPathFromTextUsbHub },
>+ {L"UsbCDCData", DevPathFromTextUsbCDCData },
>+ {L"UsbSmartCard", DevPathFromTextUsbSmartCard },
>+ {L"UsbVideo", DevPathFromTextUsbVideo },
>+ {L"UsbDiagnostic", DevPathFromTextUsbDiagnostic },
>+ {L"UsbWireless", DevPathFromTextUsbWireless },
>+ {L"UsbDeviceFirmwareUpdate",
>DevPathFromTextUsbDeviceFirmwareUpdate },
>+ {L"UsbIrdaBridge", DevPathFromTextUsbIrdaBridge },
>+ {L"UsbTestAndMeasurement",
>DevPathFromTextUsbTestAndMeasurement },
>+ {L"UsbWwid", DevPathFromTextUsbWwid },
>+ {L"Unit", DevPathFromTextUnit },
>+ {L"iSCSI", DevPathFromTextiSCSI },
>+ {L"Vlan", DevPathFromTextVlan },
>+ {L"Uri", DevPathFromTextUri },
>+ {L"Bluetooth", DevPathFromTextBluetooth },
>+ {L"Wi-Fi", DevPathFromTextWiFi },
>+ {L"MediaPath", DevPathFromTextMediaPath },
>+ {L"HD", DevPathFromTextHD },
>+ {L"CDROM", DevPathFromTextCDROM },
>+ {L"VenMedia", DevPathFromTextVenMedia },
>+ {L"Media", DevPathFromTextMedia },
>+ {L"Fv", DevPathFromTextFv },
>+ {L"FvFile", DevPathFromTextFvFile },
>+ {L"Offset", DevPathFromTextRelativeOffsetRange },
>+ {L"RamDisk", DevPathFromTextRamDisk },
>+ {L"VirtualDisk", DevPathFromTextVirtualDisk },
>+ {L"VirtualCD", DevPathFromTextVirtualCd },
>+ {L"PersistentVirtualDisk", DevPathFromTextPersistentVirtualDisk },
>+ {L"PersistentVirtualCD", DevPathFromTextPersistentVirtualCd },
>+
>+ {L"BbsPath", DevPathFromTextBbsPath },
>+ {L"BBS", DevPathFromTextBBS },
>+ {L"Sata", DevPathFromTextSata },
>+ {NULL, NULL}
>+};
>+
>+/**
>+ Convert text to the binary representation of a device node.
>+
>+ @param TextDeviceNode TextDeviceNode points to the text
>representation of a device
>+ node. Conversion starts with the first character and continues
>+ until the first non-device node character.
>+
>+ @return A pointer to the EFI device node or NULL if TextDeviceNode is
>NULL or there was
>+ insufficient memory or text unsupported.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+UefiDevicePathLibConvertTextToDeviceNode (
>+ CONST CHAR16 *TextDeviceNode
>+ )
>+{
>+ DEVICE_PATH_FROM_TEXT FromText;
>+ CHAR16 *ParamStr;
>+ EFI_DEVICE_PATH_PROTOCOL *DeviceNode;
>+ CHAR16 *DeviceNodeStr;
>+ UINTN Index;
>+
>+ if ((TextDeviceNode == NULL) || (IS_NULL (*TextDeviceNode))) {
>+ return NULL;
>+ }
>+
>+ ParamStr = NULL;
>+ FromText = NULL;
>+ DeviceNodeStr = UefiDevicePathLibStrDuplicate (TextDeviceNode);
>+ ASSERT (DeviceNodeStr != NULL);
>+
>+ for (Index = 0;
>mUefiDevicePathLibDevPathFromTextTable[Index].Function != NULL;
>Index++) {
>+ ParamStr = GetParamByNodeName (DeviceNodeStr,
>mUefiDevicePathLibDevPathFromTextTable[Index].DevicePathNodeText);
>+ if (ParamStr != NULL) {
>+ FromText = mUefiDevicePathLibDevPathFromTextTable[Index].Function;
>+ break;
>+ }
>+ }
>+
>+ if (FromText == NULL) {
>+ //
>+ // A file path
>+ //
>+ FromText = DevPathFromTextFilePath;
>+ DeviceNode = FromText (DeviceNodeStr);
>+ } else {
>+ DeviceNode = FromText (ParamStr);
>+ free (ParamStr);
>+ }
>+
>+ free (DeviceNodeStr);
>+
>+ return DeviceNode;
>+}
>+
>+/**
>+ Convert text to the binary representation of a device path.
>+
>+
>+ @param TextDevicePath TextDevicePath points to the text representation
>of a device
>+ path. Conversion starts with the first character and continues
>+ until the first non-device node character.
>+
>+ @return A pointer to the allocated device path or NULL if TextDeviceNode
>is NULL or
>+ there was insufficient memory.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+UefiDevicePathLibConvertTextToDevicePath (
>+ CONST CHAR16 *TextDevicePath
>+ )
>+{
>+ EFI_DEVICE_PATH_PROTOCOL *DeviceNode;
>+ EFI_DEVICE_PATH_PROTOCOL *NewDevicePath;
>+ CHAR16 *DevicePathStr;
>+ CHAR16 *Str;
>+ CHAR16 *DeviceNodeStr;
>+ BOOLEAN IsInstanceEnd;
>+ EFI_DEVICE_PATH_PROTOCOL *DevicePath;
>+
>+ if ((TextDevicePath == NULL) || (IS_NULL (*TextDevicePath))) {
>+ return NULL;
>+ }
>+
>+ DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) AllocatePool
>(END_DEVICE_PATH_LENGTH);
>+ ASSERT (DevicePath != NULL);
>+ SetDevicePathEndNode (DevicePath);
>+
>+ DevicePathStr = UefiDevicePathLibStrDuplicate (TextDevicePath);
>+
>+ Str = DevicePathStr;
>+ while ((DeviceNodeStr = GetNextDeviceNodeStr (&Str, &IsInstanceEnd)) !=
>NULL) {
>+ DeviceNode = UefiDevicePathLibConvertTextToDeviceNode
>(DeviceNodeStr);
>+
>+ NewDevicePath = AppendDevicePathNode (DevicePath, DeviceNode);
>+ free (DevicePath);
>+ free (DeviceNode);
>+ DevicePath = NewDevicePath;
>+
>+ if (IsInstanceEnd) {
>+ DeviceNode = (EFI_DEVICE_PATH_PROTOCOL *) AllocatePool
>(END_DEVICE_PATH_LENGTH);
>+ ASSERT (DeviceNode != NULL);
>+ SetDevicePathEndNode (DeviceNode);
>+ DeviceNode->SubType = END_INSTANCE_DEVICE_PATH_SUBTYPE;
>+
>+ NewDevicePath = AppendDevicePathNode (DevicePath, DeviceNode);
>+ free (DevicePath);
>+ free (DeviceNode);
>+ DevicePath = NewDevicePath;
>+ }
>+ }
>+
>+ free (DevicePathStr);
>+ return DevicePath;
>+}
>diff --git a/BaseTools/Source/C/DevicePath/DevicePathFromText.h
>b/BaseTools/Source/C/DevicePath/DevicePathFromText.h
>new file mode 100644
>index 0000000..4c46921
>--- /dev/null
>+++ b/BaseTools/Source/C/DevicePath/DevicePathFromText.h
>@@ -0,0 +1,72 @@
>+/** @file
>+ EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL as defined in UEFI 2.0.
>+ This protocol provides service to convert text to device paths and device
>nodes.
>+
>+ Copyright (c) 2017, Intel Corporation. All rights reserved.<BR>
>+ This program and the accompanying materials
>+ are licensed and made available under the terms and conditions of the BSD
>License
>+ which accompanies this distribution. The full text of the license may be
>found at
>+ http://opensource.org/licenses/bsd-license.php
>+
>+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+**/
>+
>+#ifndef __DEVICE_PATH_FROM_TEXT_PROTOCOL_H__
>+#define __DEVICE_PATH_FROM_TEXT_PROTOCOL_H__
>+
>+///
>+/// Device Path From Text protocol
>+///
>+#define EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL_GUID \
>+ { \
>+ 0x5c99a21, 0xc70f, 0x4ad2, {0x8a, 0x5f, 0x35, 0xdf, 0x33, 0x43, 0xf5, 0x1e }
>\
>+ }
>+
>+/**
>+ Convert text to the binary representation of a device node.
>+
>+ @param TextDeviceNode TextDeviceNode points to the text
>representation of a device
>+ node. Conversion starts with the first character and continues
>+ until the first non-device node character.
>+
>+ @retval a_pointer Pointer to the EFI device node.
>+ @retval NULL if TextDeviceNode is NULL or there was insufficient
>memory.
>+
>+**/
>+typedef
>+EFI_DEVICE_PATH_PROTOCOL*
>+( *EFI_DEVICE_PATH_FROM_TEXT_NODE)(
>+ CONST CHAR16 *TextDeviceNode
>+ );
>+
>+
>+/**
>+ Convert text to the binary representation of a device node.
>+
>+ @param TextDeviceNode TextDevicePath points to the text
>representation of a device
>+ path. Conversion starts with the first character and continues
>+ until the first non-device path character.
>+
>+ @retval a_pointer Pointer to the allocated device path.
>+ @retval NULL if TextDeviceNode is NULL or there was insufficient
>memory.
>+
>+**/
>+typedef
>+EFI_DEVICE_PATH_PROTOCOL*
>+( *EFI_DEVICE_PATH_FROM_TEXT_PATH)(
>+ CONST CHAR16 *TextDevicePath
>+ );
>+
>+///
>+/// This protocol converts text to device paths and device nodes.
>+///
>+typedef struct {
>+ EFI_DEVICE_PATH_FROM_TEXT_NODE ConvertTextToDeviceNode;
>+ EFI_DEVICE_PATH_FROM_TEXT_PATH ConvertTextToDevicePath;
>+} EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL;
>+
>+extern EFI_GUID gEfiDevicePathFromTextProtocolGuid;
>+
>+#endif
>diff --git a/BaseTools/Source/C/DevicePath/DevicePathUtilities.c
>b/BaseTools/Source/C/DevicePath/DevicePathUtilities.c
>new file mode 100644
>index 0000000..07a58ee
>--- /dev/null
>+++ b/BaseTools/Source/C/DevicePath/DevicePathUtilities.c
>@@ -0,0 +1,2352 @@
>+/** @file
>+ Device Path services. The thing to remember is device paths are built out of
>+ nodes. The device path is terminated by an end node that is length
>+ sizeof(EFI_DEVICE_PATH_PROTOCOL). That would be why there is
>sizeof(EFI_DEVICE_PATH_PROTOCOL)
>+ all over this file.
>+
>+ The only place where multi-instance device paths are supported is in
>+ environment varibles. Multi-instance device paths should never be placed
>+ on a Handle.
>+
>+ Copyright (c) 2017, Intel Corporation. All rights reserved.<BR>
>+ This program and the accompanying materials
>+ are licensed and made available under the terms and conditions of the BSD
>License
>+ which accompanies this distribution. The full text of the license may be
>found at
>+ http://opensource.org/licenses/bsd-license.php.
>+
>+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+**/
>+
>+#include "UefiDevicePathLib.h"
>+#include "DevicePathUtilities.h"
>+
>+#define SAFE_STRING_CONSTRAINT_CHECK(Expression, Status) \
>+ do { \
>+ ASSERT (Expression); \
>+ if (!(Expression)) { \
>+ return Status; \
>+ } \
>+ } while (FALSE)
>+
>+
>+//
>+// Template for an end-of-device path node.
>+//
>+CONST EFI_DEVICE_PATH_PROTOCOL mUefiDevicePathLibEndDevicePath =
>{
>+ END_DEVICE_PATH_TYPE,
>+ END_ENTIRE_DEVICE_PATH_SUBTYPE,
>+ {
>+ END_DEVICE_PATH_LENGTH,
>+ 0
>+ }
>+};
>+
>+/**
>+ Determine whether a given device path is valid.
>+ If DevicePath is NULL, then ASSERT().
>+
>+ @param DevicePath A pointer to a device path data structure.
>+ @param MaxSize The maximum size of the device path data structure.
>+
>+ @retval TRUE DevicePath is valid.
>+ @retval FALSE The length of any node node in the DevicePath is less
>+ than sizeof (EFI_DEVICE_PATH_PROTOCOL).
>+ @retval FALSE If MaxSize is not zero, the size of the DevicePath
>+ exceeds MaxSize.
>+ @retval FALSE If PcdMaximumDevicePathNodeCount is not zero, the
>node
>+ count of the DevicePath exceeds
>PcdMaximumDevicePathNodeCount.
>+**/
>+BOOLEAN
>+IsDevicePathValid (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath,
>+ UINTN MaxSize
>+ )
>+{
>+ UINTN Count;
>+ UINTN Size;
>+ UINTN NodeLength;
>+
>+ ASSERT (DevicePath != NULL);
>+
>+ if (MaxSize == 0) {
>+ MaxSize = MAX_UINTN;
>+ }
>+
>+ //
>+ // Validate the input size big enough to touch the first node.
>+ //
>+ if (MaxSize < sizeof (EFI_DEVICE_PATH_PROTOCOL)) {
>+ return FALSE;
>+ }
>+
>+ for (Count = 0, Size = 0; !IsDevicePathEnd (DevicePath); DevicePath =
>NextDevicePathNode (DevicePath)) {
>+ NodeLength = DevicePathNodeLength (DevicePath);
>+ if (NodeLength < sizeof (EFI_DEVICE_PATH_PROTOCOL)) {
>+ return FALSE;
>+ }
>+
>+ if (NodeLength > MAX_UINTN - Size) {
>+ return FALSE;
>+ }
>+ Size += NodeLength;
>+
>+ //
>+ // Validate next node before touch it.
>+ //
>+ if (Size > MaxSize - END_DEVICE_PATH_LENGTH ) {
>+ return FALSE;
>+ }
>+
>+ Count++;
>+ if (Count >= MAX_DEVICE_PATH_NODE_COUNT) {
>+ return FALSE;
>+ }
>+
>+ }
>+
>+ //
>+ // Only return TRUE when the End Device Path node is valid.
>+ //
>+ return (BOOLEAN) (DevicePathNodeLength (DevicePath) ==
>END_DEVICE_PATH_LENGTH);
>+}
>+
>+
>+/**
>+ Returns the Type field of a device path node.
>+
>+ Returns the Type field of the device path node specified by Node.
>+
>+ If Node is NULL, then ASSERT().
>+
>+ @param Node A pointer to a device path node data structure.
>+
>+ @return The Type field of the device path node specified by Node.
>+
>+**/
>+UINT8
>+DevicePathType (
>+ CONST VOID *Node
>+ )
>+{
>+ ASSERT (Node != NULL);
>+ return ((EFI_DEVICE_PATH_PROTOCOL *)(Node))->Type;
>+}
>+
>+/**
>+ Returns the SubType field of a device path node.
>+
>+ Returns the SubType field of the device path node specified by Node.
>+
>+ If Node is NULL, then ASSERT().
>+
>+ @param Node A pointer to a device path node data structure.
>+
>+ @return The SubType field of the device path node specified by Node.
>+
>+**/
>+UINT8
>+DevicePathSubType (
>+ CONST VOID *Node
>+ )
>+{
>+ ASSERT (Node != NULL);
>+ return ((EFI_DEVICE_PATH_PROTOCOL *)(Node))->SubType;
>+}
>+
>+/**
>+ Returns the 16-bit Length field of a device path node.
>+
>+ Returns the 16-bit Length field of the device path node specified by Node.
>+ Node is not required to be aligned on a 16-bit boundary, so it is
>recommended
>+ that a function such as ReadUnaligned16() be used to extract the contents
>of
>+ the Length field.
>+
>+ If Node is NULL, then ASSERT().
>+
>+ @param Node A pointer to a device path node data structure.
>+
>+ @return The 16-bit Length field of the device path node specified by Node.
>+
>+**/
>+UINTN
>+DevicePathNodeLength (
>+ CONST VOID *Node
>+ )
>+{
>+ ASSERT (Node != NULL);
>+ return ReadUnaligned16 ((UINT16 *)&((EFI_DEVICE_PATH_PROTOCOL
>*)(Node))->Length[0]);
>+}
>+
>+/**
>+ Returns a pointer to the next node in a device path.
>+
>+ Returns a pointer to the device path node that follows the device path
>node
>+ specified by Node.
>+
>+ If Node is NULL, then ASSERT().
>+
>+ @param Node A pointer to a device path node data structure.
>+
>+ @return a pointer to the device path node that follows the device path
>node
>+ specified by Node.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+NextDevicePathNode (
>+ CONST VOID *Node
>+ )
>+{
>+ ASSERT (Node != NULL);
>+ return (EFI_DEVICE_PATH_PROTOCOL *)((UINT8 *)(Node) +
>DevicePathNodeLength(Node));
>+}
>+
>+/**
>+ Determines if a device path node is an end node of a device path.
>+ This includes nodes that are the end of a device path instance and nodes
>that
>+ are the end of an entire device path.
>+
>+ Determines if the device path node specified by Node is an end node of a
>device path.
>+ This includes nodes that are the end of a device path instance and nodes
>that are the
>+ end of an entire device path. If Node represents an end node of a device
>path,
>+ then TRUE is returned. Otherwise, FALSE is returned.
>+
>+ If Node is NULL, then ASSERT().
>+
>+ @param Node A pointer to a device path node data structure.
>+
>+ @retval TRUE The device path node specified by Node is an end node of
>a
>+ device path.
>+ @retval FALSE The device path node specified by Node is not an end
>node of
>+ a device path.
>+
>+**/
>+BOOLEAN
>+IsDevicePathEndType (
>+ CONST VOID *Node
>+ )
>+{
>+ ASSERT (Node != NULL);
>+ return (BOOLEAN) (DevicePathType (Node) == END_DEVICE_PATH_TYPE);
>+}
>+
>+/**
>+ Determines if a device path node is an end node of an entire device path.
>+
>+ Determines if a device path node specified by Node is an end node of an
>entire
>+ device path. If Node represents the end of an entire device path, then
>TRUE is
>+ returned. Otherwise, FALSE is returned.
>+
>+ If Node is NULL, then ASSERT().
>+
>+ @param Node A pointer to a device path node data structure.
>+
>+ @retval TRUE The device path node specified by Node is the end of an
>entire
>+ device path.
>+ @retval FALSE The device path node specified by Node is not the end of
>an
>+ entire device path.
>+
>+**/
>+BOOLEAN
>+IsDevicePathEnd (
>+ CONST VOID *Node
>+ )
>+{
>+ ASSERT (Node != NULL);
>+ return (BOOLEAN) (IsDevicePathEndType (Node) &&
>DevicePathSubType(Node) == END_ENTIRE_DEVICE_PATH_SUBTYPE);
>+}
>+
>+/**
>+ Determines if a device path node is an end node of a device path instance.
>+
>+ Determines if a device path node specified by Node is an end node of a
>device
>+ path instance. If Node represents the end of a device path instance, then
>TRUE
>+ is returned. Otherwise, FALSE is returned.
>+
>+ If Node is NULL, then ASSERT().
>+
>+ @param Node A pointer to a device path node data structure.
>+
>+ @retval TRUE The device path node specified by Node is the end of a
>device
>+ path instance.
>+ @retval FALSE The device path node specified by Node is not the end of a
>+ device path instance.
>+
>+**/
>+BOOLEAN
>+IsDevicePathEndInstance (
>+ CONST VOID *Node
>+ )
>+{
>+ ASSERT (Node != NULL);
>+ return (BOOLEAN) (IsDevicePathEndType (Node) &&
>DevicePathSubType(Node) == END_INSTANCE_DEVICE_PATH_SUBTYPE);
>+}
>+
>+/**
>+ Sets the length, in bytes, of a device path node.
>+
>+ Sets the length of the device path node specified by Node to the value
>specified
>+ by NodeLength. NodeLength is returned. Node is not required to be
>aligned on
>+ a 16-bit boundary, so it is recommended that a function such as
>WriteUnaligned16()
>+ be used to set the contents of the Length field.
>+
>+ If Node is NULL, then ASSERT().
>+ If NodeLength >= SIZE_64KB, then ASSERT().
>+ If NodeLength < sizeof (EFI_DEVICE_PATH_PROTOCOL), then ASSERT().
>+
>+ @param Node A pointer to a device path node data structure.
>+ @param Length The length, in bytes, of the device path node.
>+
>+ @return Length
>+
>+**/
>+UINT16
>+SetDevicePathNodeLength (
>+ VOID *Node,
>+ UINTN Length
>+ )
>+{
>+ ASSERT (Node != NULL);
>+ ASSERT ((Length >= sizeof (EFI_DEVICE_PATH_PROTOCOL)) && (Length <
>SIZE_64KB));
>+ return WriteUnaligned16 ((UINT16 *)&((EFI_DEVICE_PATH_PROTOCOL
>*)(Node))->Length[0], (UINT16)(Length));
>+}
>+
>+/**
>+ Fills in all the fields of a device path node that is the end of an entire device
>path.
>+
>+ Fills in all the fields of a device path node specified by Node so Node
>represents
>+ the end of an entire device path. The Type field of Node is set to
>+ END_DEVICE_PATH_TYPE, the SubType field of Node is set to
>+ END_ENTIRE_DEVICE_PATH_SUBTYPE, and the Length field of Node is set
>to
>+ END_DEVICE_PATH_LENGTH. Node is not required to be aligned on a 16-bit
>boundary,
>+ so it is recommended that a function such as WriteUnaligned16() be used to
>set
>+ the contents of the Length field.
>+
>+ If Node is NULL, then ASSERT().
>+
>+ @param Node A pointer to a device path node data structure.
>+
>+**/
>+VOID
>+SetDevicePathEndNode (
>+ VOID *Node
>+ )
>+{
>+ ASSERT (Node != NULL);
>+ memcpy (Node, &mUefiDevicePathLibEndDevicePath, sizeof
>(mUefiDevicePathLibEndDevicePath));
>+}
>+
>+/**
>+ Returns the size of a device path in bytes.
>+
>+ This function returns the size, in bytes, of the device path data structure
>+ specified by DevicePath including the end of device path node.
>+ If DevicePath is NULL or invalid, then 0 is returned.
>+
>+ @param DevicePath A pointer to a device path data structure.
>+
>+ @retval 0 If DevicePath is NULL or invalid.
>+ @retval Others The size of a device path in bytes.
>+
>+**/
>+UINTN
>+UefiDevicePathLibGetDevicePathSize (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath
>+ )
>+{
>+ CONST EFI_DEVICE_PATH_PROTOCOL *Start;
>+
>+ if (DevicePath == NULL) {
>+ return 0;
>+ }
>+
>+ if (!IsDevicePathValid (DevicePath, 0)) {
>+ return 0;
>+ }
>+
>+ //
>+ // Search for the end of the device path structure
>+ //
>+ Start = DevicePath;
>+ while (!IsDevicePathEnd (DevicePath)) {
>+ DevicePath = NextDevicePathNode (DevicePath);
>+ }
>+
>+ //
>+ // Compute the size and add back in the size of the end device path
>structure
>+ //
>+ return ((UINTN) DevicePath - (UINTN) Start) + DevicePathNodeLength
>(DevicePath);
>+}
>+
>+/**
>+ Creates a new copy of an existing device path.
>+
>+ This function allocates space for a new copy of the device path specified by
>DevicePath.
>+ If DevicePath is NULL, then NULL is returned. If the memory is successfully
>+ allocated, then the contents of DevicePath are copied to the newly
>allocated
>+ buffer, and a pointer to that buffer is returned. Otherwise, NULL is
>returned.
>+ The memory for the new device path is allocated from EFI boot services
>memory.
>+ It is the responsibility of the caller to free the memory allocated.
>+
>+ @param DevicePath A pointer to a device path data structure.
>+
>+ @retval NULL DevicePath is NULL or invalid.
>+ @retval Others A pointer to the duplicated device path.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+UefiDevicePathLibDuplicateDevicePath (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath
>+ )
>+{
>+ UINTN Size;
>+
>+ //
>+ // Compute the size
>+ //
>+ Size = GetDevicePathSize (DevicePath);
>+ if (Size == 0) {
>+ return NULL;
>+ }
>+
>+ //
>+ // Allocate space for duplicate device path
>+ //
>+
>+ return AllocateCopyPool (Size, DevicePath);
>+}
>+
>+/**
>+ Creates a new device path by appending a second device path to a first
>device path.
>+
>+ This function creates a new device path by appending a copy of
>SecondDevicePath
>+ to a copy of FirstDevicePath in a newly allocated buffer. Only the end-of-
>device-path
>+ device node from SecondDevicePath is retained. The newly created device
>path is
>+ returned. If FirstDevicePath is NULL, then it is ignored, and a duplicate of
>+ SecondDevicePath is returned. If SecondDevicePath is NULL, then it is
>ignored,
>+ and a duplicate of FirstDevicePath is returned. If both FirstDevicePath and
>+ SecondDevicePath are NULL, then a copy of an end-of-device-path is
>returned.
>+
>+ If there is not enough memory for the newly allocated buffer, then NULL is
>returned.
>+ The memory for the new device path is allocated from EFI boot services
>memory.
>+ It is the responsibility of the caller to free the memory allocated.
>+
>+ @param FirstDevicePath A pointer to a device path data structure.
>+ @param SecondDevicePath A pointer to a device path data structure.
>+
>+ @retval NULL If there is not enough memory for the newly allocated
>buffer.
>+ @retval NULL If FirstDevicePath or SecondDevicePath is invalid.
>+ @retval Others A pointer to the new device path if success.
>+ Or a copy an end-of-device-path if both FirstDevicePath and
>SecondDevicePath are NULL.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+UefiDevicePathLibAppendDevicePath (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *FirstDevicePath,
>+ CONST EFI_DEVICE_PATH_PROTOCOL *SecondDevicePath
>+ )
>+{
>+ UINTN Size;
>+ UINTN Size1;
>+ UINTN Size2;
>+ EFI_DEVICE_PATH_PROTOCOL *NewDevicePath;
>+ EFI_DEVICE_PATH_PROTOCOL *DevicePath2;
>+
>+ //
>+ // If there's only 1 path, just duplicate it.
>+ //
>+ if (FirstDevicePath == NULL) {
>+ return DuplicateDevicePath ((SecondDevicePath != NULL) ?
>SecondDevicePath : &mUefiDevicePathLibEndDevicePath);
>+ }
>+
>+ if (SecondDevicePath == NULL) {
>+ return DuplicateDevicePath (FirstDevicePath);
>+ }
>+
>+ if (!IsDevicePathValid (FirstDevicePath, 0) || !IsDevicePathValid
>(SecondDevicePath, 0)) {
>+ return NULL;
>+ }
>+
>+ //
>+ // Allocate space for the combined device path. It only has one end node of
>+ // length EFI_DEVICE_PATH_PROTOCOL.
>+ //
>+ Size1 = GetDevicePathSize (FirstDevicePath);
>+ Size2 = GetDevicePathSize (SecondDevicePath);
>+ Size = Size1 + Size2 - END_DEVICE_PATH_LENGTH;
>+
>+ NewDevicePath = AllocatePool (Size);
>+
>+ if (NewDevicePath != NULL) {
>+ NewDevicePath = memcpy (NewDevicePath, FirstDevicePath, Size1);
>+ //
>+ // Over write FirstDevicePath EndNode and do the copy
>+ //
>+ DevicePath2 = (EFI_DEVICE_PATH_PROTOCOL *) ((CHAR8 *)
>NewDevicePath +
>+ (Size1 - END_DEVICE_PATH_LENGTH));
>+ memcpy (DevicePath2, SecondDevicePath, Size2);
>+ }
>+
>+ return NewDevicePath;
>+}
>+
>+/**
>+ Creates a new path by appending the device node to the device path.
>+
>+ This function creates a new device path by appending a copy of the device
>node
>+ specified by DevicePathNode to a copy of the device path specified by
>DevicePath
>+ in an allocated buffer. The end-of-device-path device node is moved after
>the
>+ end of the appended device node.
>+ If DevicePathNode is NULL then a copy of DevicePath is returned.
>+ If DevicePath is NULL then a copy of DevicePathNode, followed by an end-
>of-device
>+ path device node is returned.
>+ If both DevicePathNode and DevicePath are NULL then a copy of an end-of-
>device-path
>+ device node is returned.
>+ If there is not enough memory to allocate space for the new device path,
>then
>+ NULL is returned.
>+ The memory is allocated from EFI boot services memory. It is the
>responsibility
>+ of the caller to free the memory allocated.
>+
>+ @param DevicePath A pointer to a device path data structure.
>+ @param DevicePathNode A pointer to a single device path node.
>+
>+ @retval NULL If there is not enough memory for the new device path.
>+ @retval Others A pointer to the new device path if success.
>+ A copy of DevicePathNode followed by an end-of-device-path
>node
>+ if both FirstDevicePath and SecondDevicePath are NULL.
>+ A copy of an end-of-device-path node if both FirstDevicePath
>+ and SecondDevicePath are NULL.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+UefiDevicePathLibAppendDevicePathNode (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath,
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePathNode
>+ )
>+{
>+ EFI_DEVICE_PATH_PROTOCOL *TempDevicePath;
>+ EFI_DEVICE_PATH_PROTOCOL *NextNode;
>+ EFI_DEVICE_PATH_PROTOCOL *NewDevicePath;
>+ UINTN NodeLength;
>+
>+ if (DevicePathNode == NULL) {
>+ return DuplicateDevicePath ((DevicePath != NULL) ? DevicePath :
>&mUefiDevicePathLibEndDevicePath);
>+ }
>+ //
>+ // Build a Node that has a terminator on it
>+ //
>+ NodeLength = DevicePathNodeLength (DevicePathNode);
>+
>+ TempDevicePath = AllocatePool (NodeLength +
>END_DEVICE_PATH_LENGTH);
>+ if (TempDevicePath == NULL) {
>+ return NULL;
>+ }
>+ TempDevicePath = memcpy (TempDevicePath, DevicePathNode,
>NodeLength);
>+ //
>+ // Add and end device path node to convert Node to device path
>+ //
>+ NextNode = NextDevicePathNode (TempDevicePath);
>+ SetDevicePathEndNode (NextNode);
>+ //
>+ // Append device paths
>+ //
>+ NewDevicePath = AppendDevicePath (DevicePath, TempDevicePath);
>+
>+ free (TempDevicePath);
>+
>+ return NewDevicePath;
>+}
>+
>+/**
>+ Creates a new device path by appending the specified device path instance
>to the specified device
>+ path.
>+
>+ This function creates a new device path by appending a copy of the device
>path
>+ instance specified by DevicePathInstance to a copy of the device path
>specified
>+ by DevicePath in a allocated buffer.
>+ The end-of-device-path device node is moved after the end of the
>appended device
>+ path instance and a new end-of-device-path-instance node is inserted
>between.
>+ If DevicePath is NULL, then a copy if DevicePathInstance is returned.
>+ If DevicePathInstance is NULL, then NULL is returned.
>+ If DevicePath or DevicePathInstance is invalid, then NULL is returned.
>+ If there is not enough memory to allocate space for the new device path,
>then
>+ NULL is returned.
>+ The memory is allocated from EFI boot services memory. It is the
>responsibility
>+ of the caller to free the memory allocated.
>+
>+ @param DevicePath A pointer to a device path data structure.
>+ @param DevicePathInstance A pointer to a device path instance.
>+
>+ @return A pointer to the new device path.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+UefiDevicePathLibAppendDevicePathInstance (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath,
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePathInstance
>+ )
>+{
>+ EFI_DEVICE_PATH_PROTOCOL *NewDevicePath;
>+ EFI_DEVICE_PATH_PROTOCOL *TempDevicePath;
>+ UINTN SrcSize;
>+ UINTN InstanceSize;
>+
>+ if (DevicePath == NULL) {
>+ return DuplicateDevicePath (DevicePathInstance);
>+ }
>+
>+ if (DevicePathInstance == NULL) {
>+ return NULL;
>+ }
>+
>+ if (!IsDevicePathValid (DevicePath, 0) || !IsDevicePathValid
>(DevicePathInstance, 0)) {
>+ return NULL;
>+ }
>+
>+ SrcSize = GetDevicePathSize (DevicePath);
>+ InstanceSize = GetDevicePathSize (DevicePathInstance);
>+
>+ NewDevicePath = AllocatePool (SrcSize + InstanceSize);
>+ if (NewDevicePath != NULL) {
>+
>+ TempDevicePath = memcpy (NewDevicePath, DevicePath, SrcSize);;
>+
>+ while (!IsDevicePathEnd (TempDevicePath)) {
>+ TempDevicePath = NextDevicePathNode (TempDevicePath);
>+ }
>+
>+ TempDevicePath->SubType = END_INSTANCE_DEVICE_PATH_SUBTYPE;
>+ TempDevicePath = NextDevicePathNode (TempDevicePath);
>+ memcpy (TempDevicePath, DevicePathInstance, InstanceSize);
>+ }
>+
>+ return NewDevicePath;
>+}
>+
>+/**
>+ Creates a copy of the current device path instance and returns a pointer to
>the next device path
>+ instance.
>+
>+ This function creates a copy of the current device path instance. It also
>updates
>+ DevicePath to point to the next device path instance in the device path (or
>NULL
>+ if no more) and updates Size to hold the size of the device path instance
>copy.
>+ If DevicePath is NULL, then NULL is returned.
>+ If DevicePath points to a invalid device path, then NULL is returned.
>+ If there is not enough memory to allocate space for the new device path,
>then
>+ NULL is returned.
>+ The memory is allocated from EFI boot services memory. It is the
>responsibility
>+ of the caller to free the memory allocated.
>+ If Size is NULL, then ASSERT().
>+
>+ @param DevicePath On input, this holds the pointer to the current
>+ device path instance. On output, this holds
>+ the pointer to the next device path instance
>+ or NULL if there are no more device path
>+ instances in the device path pointer to a
>+ device path data structure.
>+ @param Size On output, this holds the size of the device
>+ path instance, in bytes or zero, if DevicePath
>+ is NULL.
>+
>+ @return A pointer to the current device path instance.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+UefiDevicePathLibGetNextDevicePathInstance (
>+ EFI_DEVICE_PATH_PROTOCOL **DevicePath,
>+ UINTN *Size
>+ )
>+{
>+ EFI_DEVICE_PATH_PROTOCOL *DevPath;
>+ EFI_DEVICE_PATH_PROTOCOL *ReturnValue;
>+ UINT8 Temp;
>+
>+ ASSERT (Size != NULL);
>+
>+ if (DevicePath == NULL || *DevicePath == NULL) {
>+ *Size = 0;
>+ return NULL;
>+ }
>+
>+ if (!IsDevicePathValid (*DevicePath, 0)) {
>+ return NULL;
>+ }
>+
>+ //
>+ // Find the end of the device path instance
>+ //
>+ DevPath = *DevicePath;
>+ while (!IsDevicePathEndType (DevPath)) {
>+ DevPath = NextDevicePathNode (DevPath);
>+ }
>+
>+ //
>+ // Compute the size of the device path instance
>+ //
>+ *Size = ((UINTN) DevPath - (UINTN) (*DevicePath)) + sizeof
>(EFI_DEVICE_PATH_PROTOCOL);
>+
>+ //
>+ // Make a copy and return the device path instance
>+ //
>+ Temp = DevPath->SubType;
>+ DevPath->SubType = END_ENTIRE_DEVICE_PATH_SUBTYPE;
>+ ReturnValue = DuplicateDevicePath (*DevicePath);
>+ DevPath->SubType = Temp;
>+
>+ //
>+ // If DevPath is the end of an entire device path, then another instance
>+ // does not follow, so *DevicePath is set to NULL.
>+ //
>+ if (DevicePathSubType (DevPath) == END_ENTIRE_DEVICE_PATH_SUBTYPE)
>{
>+ *DevicePath = NULL;
>+ } else {
>+ *DevicePath = NextDevicePathNode (DevPath);
>+ }
>+
>+ return ReturnValue;
>+}
>+
>+/**
>+ Creates a device node.
>+
>+ This function creates a new device node in a newly allocated buffer of size
>+ NodeLength and initializes the device path node header with NodeType
>and NodeSubType.
>+ The new device path node is returned.
>+ If NodeLength is smaller than a device path header, then NULL is returned.
>+ If there is not enough memory to allocate space for the new device path,
>then
>+ NULL is returned.
>+ The memory is allocated from EFI boot services memory. It is the
>responsibility
>+ of the caller to free the memory allocated.
>+
>+ @param NodeType The device node type for the new device
>node.
>+ @param NodeSubType The device node sub-type for the new
>device node.
>+ @param NodeLength The length of the new device node.
>+
>+ @return The new device path.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+UefiDevicePathLibCreateDeviceNode (
>+ UINT8 NodeType,
>+ UINT8 NodeSubType,
>+ UINT16 NodeLength
>+ )
>+{
>+ EFI_DEVICE_PATH_PROTOCOL *DevicePath;
>+
>+ if (NodeLength < sizeof (EFI_DEVICE_PATH_PROTOCOL)) {
>+ //
>+ // NodeLength is less than the size of the header.
>+ //
>+ return NULL;
>+ }
>+
>+ DevicePath = AllocateZeroPool (NodeLength);
>+ if (DevicePath != NULL) {
>+ DevicePath->Type = NodeType;
>+ DevicePath->SubType = NodeSubType;
>+ SetDevicePathNodeLength (DevicePath, NodeLength);
>+ }
>+
>+ return DevicePath;
>+}
>+
>+/**
>+ Determines if a device path is single or multi-instance.
>+
>+ This function returns TRUE if the device path specified by DevicePath is
>+ multi-instance.
>+ Otherwise, FALSE is returned.
>+ If DevicePath is NULL or invalid, then FALSE is returned.
>+
>+ @param DevicePath A pointer to a device path data structure.
>+
>+ @retval TRUE DevicePath is multi-instance.
>+ @retval FALSE DevicePath is not multi-instance, or DevicePath
>+ is NULL or invalid.
>+
>+**/
>+BOOLEAN
>+UefiDevicePathLibIsDevicePathMultiInstance (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath
>+ )
>+{
>+ CONST EFI_DEVICE_PATH_PROTOCOL *Node;
>+
>+ if (DevicePath == NULL) {
>+ return FALSE;
>+ }
>+
>+ if (!IsDevicePathValid (DevicePath, 0)) {
>+ return FALSE;
>+ }
>+
>+ Node = DevicePath;
>+ while (!IsDevicePathEnd (Node)) {
>+ if (IsDevicePathEndInstance (Node)) {
>+ return TRUE;
>+ }
>+
>+ Node = NextDevicePathNode (Node);
>+ }
>+
>+ return FALSE;
>+}
>+
>+
>+/**
>+ Retrieves the device path protocol from a handle.
>+
>+ This function returns the device path protocol from the handle specified by
>Handle.
>+ If Handle is NULL or Handle does not contain a device path protocol, then
>NULL
>+ is returned.
>+
>+ @param Handle The handle from which to retrieve the device
>+ path protocol.
>+
>+ @return The device path protocol from the handle specified by Handle.
>+
>+**/
>+/*
>+EFI_DEVICE_PATH_PROTOCOL *
>+DevicePathFromHandle (
>+ EFI_HANDLE Handle
>+ )
>+{
>+ EFI_DEVICE_PATH_PROTOCOL *DevicePath;
>+ EFI_STATUS Status;
>+
>+ Status = gBS->HandleProtocol (
>+ Handle,
>+ &gEfiDevicePathProtocolGuid,
>+ (VOID *) &DevicePath
>+ );
>+ if (EFI_ERROR (Status)) {
>+ DevicePath = NULL;
>+ }
>+ return DevicePath;
>+}
>+*/
>+/**
>+ Allocates a device path for a file and appends it to an existing device path.
>+
>+ If Device is a valid device handle that contains a device path protocol, then a
>device path for
>+ the file specified by FileName is allocated and appended to the device path
>associated with the
>+ handle Device. The allocated device path is returned. If Device is NULL or
>Device is a handle
>+ that does not support the device path protocol, then a device path
>containing a single device
>+ path node for the file specified by FileName is allocated and returned.
>+ The memory for the new device path is allocated from EFI boot services
>memory. It is the responsibility
>+ of the caller to free the memory allocated.
>+
>+ If FileName is NULL, then ASSERT().
>+ If FileName is not aligned on a 16-bit boundary, then ASSERT().
>+
>+ @param Device A pointer to a device handle. This parameter
>+ is optional and may be NULL.
>+ @param FileName A pointer to a Null-terminated Unicode string.
>+
>+ @return The allocated device path.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+FileDevicePath (
>+ EFI_HANDLE Device, OPTIONAL
>+ CONST CHAR16 *FileName
>+ )
>+{
>+ UINTN Size;
>+ FILEPATH_DEVICE_PATH *FilePath;
>+ EFI_DEVICE_PATH_PROTOCOL *DevicePath;
>+ EFI_DEVICE_PATH_PROTOCOL *FileDevicePath;
>+
>+ DevicePath = NULL;
>+
>+ Size = StrSize (FileName);
>+ FileDevicePath = AllocatePool (Size + SIZE_OF_FILEPATH_DEVICE_PATH +
>END_DEVICE_PATH_LENGTH);
>+ if (FileDevicePath != NULL) {
>+ FilePath = (FILEPATH_DEVICE_PATH *) FileDevicePath;
>+ FilePath->Header.Type = MEDIA_DEVICE_PATH;
>+ FilePath->Header.SubType = MEDIA_FILEPATH_DP;
>+ memcpy (&FilePath->PathName, FileName, Size);
>+ SetDevicePathNodeLength (&FilePath->Header, Size +
>SIZE_OF_FILEPATH_DEVICE_PATH);
>+ SetDevicePathEndNode (NextDevicePathNode (&FilePath->Header));
>+
>+ //if (Device != NULL) {
>+ // DevicePath = DevicePathFromHandle (Device);
>+ //}
>+
>+ DevicePath = AppendDevicePath (DevicePath, FileDevicePath);
>+ free (FileDevicePath);
>+ }
>+
>+ return DevicePath;
>+}
>+
>+CHAR16
>+InternalCharToUpper (
>+ CHAR16 Char
>+ )
>+{
>+ if (Char >= L'a' && Char <= L'z') {
>+ return (CHAR16) (Char - (L'a' - L'A'));
>+ }
>+
>+ return Char;
>+}
>+
>+UINTN
>+StrnLenS (
>+ CONST CHAR16 *String,
>+ UINTN MaxSize
>+ )
>+{
>+ UINTN Length;
>+
>+ ASSERT (((UINTN) String & BIT0) == 0);
>+
>+ //
>+ // If String is a null pointer or MaxSize is 0, then the StrnLenS function
>returns zero.
>+ //
>+ if ((String == NULL) || (MaxSize == 0)) {
>+ return 0;
>+ }
>+
>+ Length = 0;
>+ while (String[Length] != 0) {
>+ if (Length >= MaxSize - 1) {
>+ return MaxSize;
>+ }
>+ Length++;
>+ }
>+ return Length;
>+}
>+
>+
>+VOID *
>+InternalAllocatePool (
>+ UINTN AllocationSize
>+ )
>+{
>+ VOID * Memory;
>+
>+ Memory = malloc(AllocationSize);
>+ ASSERT(Memory != NULL);
>+ return Memory;
>+}
>+
>+
>+VOID *
>+InternalReallocatePool (
>+ UINTN OldSize,
>+ UINTN NewSize,
>+ VOID *OldBuffer OPTIONAL
>+ )
>+{
>+ VOID *NewBuffer;
>+
>+ NewBuffer = AllocateZeroPool (NewSize);
>+ if (NewBuffer != NULL && OldBuffer != NULL) {
>+ memcpy (NewBuffer, OldBuffer, MIN (OldSize, NewSize));
>+ free(OldBuffer);
>+ }
>+ return NewBuffer;
>+}
>+
>+VOID *
>+ReallocatePool (
>+ UINTN OldSize,
>+ UINTN NewSize,
>+ VOID *OldBuffer OPTIONAL
>+ )
>+{
>+ return InternalReallocatePool (OldSize, NewSize, OldBuffer);
>+}
>+
>+/**
>+ Returns the length of a Null-terminated Unicode string.
>+
>+ This function returns the number of Unicode characters in the Null-
>terminated
>+ Unicode string specified by String.
>+
>+ If String is NULL, then ASSERT().
>+ If String is not aligned on a 16-bit boundary, then ASSERT().
>+ If PcdMaximumUnicodeStringLength is not zero, and String contains more
>than
>+ PcdMaximumUnicodeStringLength Unicode characters, not including the
>+ Null-terminator, then ASSERT().
>+
>+ @param String A pointer to a Null-terminated Unicode string.
>+
>+ @return The length of String.
>+
>+**/
>+UINTN
>+StrLen (
>+ CONST CHAR16 *String
>+ )
>+{
>+ UINTN Length;
>+
>+ ASSERT (String != NULL);
>+ ASSERT (((UINTN) String & BIT0) == 0);
>+
>+ for (Length = 0; *String != L'\0'; String++, Length++) {
>+ //
>+ // If PcdMaximumUnicodeStringLength is not zero,
>+ // length should not more than PcdMaximumUnicodeStringLength
>+ //
>+ }
>+ return Length;
>+}
>+
>+BOOLEAN
>+InternalSafeStringIsOverlap (
>+ IN VOID *Base1,
>+ IN UINTN Size1,
>+ IN VOID *Base2,
>+ IN UINTN Size2
>+ )
>+{
>+ if ((((UINTN)Base1 >= (UINTN)Base2) && ((UINTN)Base1 < (UINTN)Base2 +
>Size2)) ||
>+ (((UINTN)Base2 >= (UINTN)Base1) && ((UINTN)Base2 < (UINTN)Base1 +
>Size1))) {
>+ return TRUE;
>+ }
>+ return FALSE;
>+}
>+
>+BOOLEAN
>+InternalSafeStringNoStrOverlap (
>+ IN CHAR16 *Str1,
>+ IN UINTN Size1,
>+ IN CHAR16 *Str2,
>+ IN UINTN Size2
>+ )
>+{
>+ return !InternalSafeStringIsOverlap (Str1, Size1 * sizeof(CHAR16), Str2, Size2
>* sizeof(CHAR16));
>+}
>+
>+RETURN_STATUS
>+StrDecimalToUintnS (
>+ CONST CHAR16 *String,
>+ CHAR16 **EndPointer, OPTIONAL
>+ UINTN *Data
>+ )
>+{
>+ ASSERT (((UINTN) String & BIT0) == 0);
>+
>+ //
>+ // 1. Neither String nor Data shall be a null pointer.
>+ //
>+ SAFE_STRING_CONSTRAINT_CHECK ((String != NULL),
>RETURN_INVALID_PARAMETER);
>+ SAFE_STRING_CONSTRAINT_CHECK ((Data != NULL),
>RETURN_INVALID_PARAMETER);
>+
>+ //
>+ // 2. The length of String shall not be greater than RSIZE_MAX.
>+ //
>+ if (RSIZE_MAX != 0) {
>+ SAFE_STRING_CONSTRAINT_CHECK ((StrnLenS (String, RSIZE_MAX + 1) <=
>RSIZE_MAX), RETURN_INVALID_PARAMETER);
>+ }
>+
>+ if (EndPointer != NULL) {
>+ *EndPointer = (CHAR16 *) String;
>+ }
>+
>+ //
>+ // Ignore the pad spaces (space or tab)
>+ //
>+ while ((*String == L' ') || (*String == L'\t')) {
>+ String++;
>+ }
>+
>+ //
>+ // Ignore leading Zeros after the spaces
>+ //
>+ while (*String == L'0') {
>+ String++;
>+ }
>+
>+ *Data = 0;
>+
>+ while (InternalIsDecimalDigitCharacter (*String)) {
>+ //
>+ // If the number represented by String overflows according to the range
>+ // defined by UINTN, then MAX_UINTN is stored in *Data and
>+ // RETURN_UNSUPPORTED is returned.
>+ //
>+ if (*Data > ((MAX_UINTN - (*String - L'0')) / 10)) {
>+ *Data = MAX_UINTN;
>+ if (EndPointer != NULL) {
>+ *EndPointer = (CHAR16 *) String;
>+ }
>+ return RETURN_UNSUPPORTED;
>+ }
>+
>+ *Data = *Data * 10 + (*String - L'0');
>+ String++;
>+ }
>+
>+ if (EndPointer != NULL) {
>+ *EndPointer = (CHAR16 *) String;
>+ }
>+ return RETURN_SUCCESS;
>+}
>+
>+/**
>+ Convert a Null-terminated Unicode decimal string to a value of type UINT64.
>+
>+ This function outputs a value of type UINT64 by interpreting the contents of
>+ the Unicode string specified by String as a decimal number. The format of
>the
>+ input Unicode string String is:
>+
>+ [spaces] [decimal digits].
>+
>+ The valid decimal digit character is in the range [0-9]. The function will
>+ ignore the pad space, which includes spaces or tab characters, before
>+ [decimal digits]. The running zero in the beginning of [decimal digits] will
>+ be ignored. Then, the function stops at the first character that is a not a
>+ valid decimal character or a Null-terminator, whichever one comes first.
>+
>+ If String is NULL, then ASSERT().
>+ If Data is NULL, then ASSERT().
>+ If String is not aligned in a 16-bit boundary, then ASSERT().
>+ If PcdMaximumUnicodeStringLength is not zero, and String contains more
>than
>+ PcdMaximumUnicodeStringLength Unicode characters, not including the
>+ Null-terminator, then ASSERT().
>+
>+ If String has no valid decimal digits in the above format, then 0 is stored
>+ at the location pointed to by Data.
>+ If the number represented by String exceeds the range defined by UINT64,
>then
>+ MAX_UINT64 is stored at the location pointed to by Data.
>+
>+ If EndPointer is not NULL, a pointer to the character that stopped the scan
>+ is stored at the location pointed to by EndPointer. If String has no valid
>+ decimal digits right after the optional pad spaces, the value of String is
>+ stored at the location pointed to by EndPointer.
>+
>+ @param String Pointer to a Null-terminated Unicode string.
>+ @param EndPointer Pointer to character that stops scan.
>+ @param Data Pointer to the converted value.
>+
>+ @retval RETURN_SUCCESS Value is translated from String.
>+ @retval RETURN_INVALID_PARAMETER If String is NULL.
>+ If Data is NULL.
>+ If PcdMaximumUnicodeStringLength is not
>+ zero, and String contains more than
>+ PcdMaximumUnicodeStringLength Unicode
>+ characters, not including the
>+ Null-terminator.
>+ @retval RETURN_UNSUPPORTED If the number represented by String
>exceeds
>+ the range defined by UINT64.
>+
>+**/
>+RETURN_STATUS
>+StrDecimalToUint64S (
>+ CONST CHAR16 *String,
>+ CHAR16 **EndPointer, OPTIONAL
>+ UINT64 *Data
>+ )
>+{
>+ ASSERT (((UINTN) String & BIT0) == 0);
>+
>+ //
>+ // 1. Neither String nor Data shall be a null pointer.
>+ //
>+ SAFE_STRING_CONSTRAINT_CHECK ((String != NULL),
>RETURN_INVALID_PARAMETER);
>+ SAFE_STRING_CONSTRAINT_CHECK ((Data != NULL),
>RETURN_INVALID_PARAMETER);
>+
>+ //
>+ // 2. The length of String shall not be greater than RSIZE_MAX.
>+ //
>+ if (RSIZE_MAX != 0) {
>+ SAFE_STRING_CONSTRAINT_CHECK ((StrnLenS (String, RSIZE_MAX + 1) <=
>RSIZE_MAX), RETURN_INVALID_PARAMETER);
>+ }
>+
>+ if (EndPointer != NULL) {
>+ *EndPointer = (CHAR16 *) String;
>+ }
>+
>+ //
>+ // Ignore the pad spaces (space or tab)
>+ //
>+ while ((*String == L' ') || (*String == L'\t')) {
>+ String++;
>+ }
>+
>+ //
>+ // Ignore leading Zeros after the spaces
>+ //
>+ while (*String == L'0') {
>+ String++;
>+ }
>+
>+ *Data = 0;
>+
>+ while (InternalIsDecimalDigitCharacter (*String)) {
>+ //
>+ // If the number represented by String overflows according to the range
>+ // defined by UINT64, then MAX_UINT64 is stored in *Data and
>+ // RETURN_UNSUPPORTED is returned.
>+ //
>+ if (*Data > ((MAX_UINT64 - (*String - L'0'))/10)) {
>+ *Data = MAX_UINT64;
>+ if (EndPointer != NULL) {
>+ *EndPointer = (CHAR16 *) String;
>+ }
>+ return RETURN_UNSUPPORTED;
>+ }
>+
>+ *Data = (*Data) * 10 + (*String - L'0');
>+ String++;
>+ }
>+
>+ if (EndPointer != NULL) {
>+ *EndPointer = (CHAR16 *) String;
>+ }
>+ return RETURN_SUCCESS;
>+}
>+
>+/**
>+ Convert a Null-terminated Unicode hexadecimal string to a value of type
>+ UINTN.
>+
>+ This function outputs a value of type UINTN by interpreting the contents of
>+ the Unicode string specified by String as a hexadecimal number. The format
>of
>+ the input Unicode string String is:
>+
>+ [spaces][zeros][x][hexadecimal digits].
>+
>+ The valid hexadecimal digit character is in the range [0-9], [a-f] and [A-F].
>+ The prefix "0x" is optional. Both "x" and "X" is allowed in "0x" prefix.
>+ If "x" appears in the input string, it must be prefixed with at least one 0.
>+ The function will ignore the pad space, which includes spaces or tab
>+ characters, before [zeros], [x] or [hexadecimal digit]. The running zero
>+ before [x] or [hexadecimal digit] will be ignored. Then, the decoding starts
>+ after [x] or the first valid hexadecimal digit. Then, the function stops at
>+ the first character that is a not a valid hexadecimal character or NULL,
>+ whichever one comes first.
>+
>+ If String is NULL, then ASSERT().
>+ If Data is NULL, then ASSERT().
>+ If String is not aligned in a 16-bit boundary, then ASSERT().
>+ If PcdMaximumUnicodeStringLength is not zero, and String contains more
>than
>+ PcdMaximumUnicodeStringLength Unicode characters, not including the
>+ Null-terminator, then ASSERT().
>+
>+ If String has no valid hexadecimal digits in the above format, then 0 is
>+ stored at the location pointed to by Data.
>+ If the number represented by String exceeds the range defined by UINTN,
>then
>+ MAX_UINTN is stored at the location pointed to by Data.
>+
>+ If EndPointer is not NULL, a pointer to the character that stopped the scan
>+ is stored at the location pointed to by EndPointer. If String has no valid
>+ hexadecimal digits right after the optional pad spaces, the value of String
>+ is stored at the location pointed to by EndPointer.
>+
>+ @param String Pointer to a Null-terminated Unicode string.
>+ @param EndPointer Pointer to character that stops scan.
>+ @param Data Pointer to the converted value.
>+
>+ @retval RETURN_SUCCESS Value is translated from String.
>+ @retval RETURN_INVALID_PARAMETER If String is NULL.
>+ If Data is NULL.
>+ If PcdMaximumUnicodeStringLength is not
>+ zero, and String contains more than
>+ PcdMaximumUnicodeStringLength Unicode
>+ characters, not including the
>+ Null-terminator.
>+ @retval RETURN_UNSUPPORTED If the number represented by String
>exceeds
>+ the range defined by UINTN.
>+
>+**/
>+RETURN_STATUS
>+StrHexToUintnS (
>+ CONST CHAR16 *String,
>+ CHAR16 **EndPointer, OPTIONAL
>+ UINTN *Data
>+ )
>+{
>+ ASSERT (((UINTN) String & BIT0) == 0);
>+
>+ //
>+ // 1. Neither String nor Data shall be a null pointer.
>+ //
>+ SAFE_STRING_CONSTRAINT_CHECK ((String != NULL),
>RETURN_INVALID_PARAMETER);
>+ SAFE_STRING_CONSTRAINT_CHECK ((Data != NULL),
>RETURN_INVALID_PARAMETER);
>+
>+ //
>+ // 2. The length of String shall not be greater than RSIZE_MAX.
>+ //
>+ if (RSIZE_MAX != 0) {
>+ SAFE_STRING_CONSTRAINT_CHECK ((StrnLenS (String, RSIZE_MAX + 1) <=
>RSIZE_MAX), RETURN_INVALID_PARAMETER);
>+ }
>+
>+ if (EndPointer != NULL) {
>+ *EndPointer = (CHAR16 *) String;
>+ }
>+
>+ //
>+ // Ignore the pad spaces (space or tab)
>+ //
>+ while ((*String == L' ') || (*String == L'\t')) {
>+ String++;
>+ }
>+
>+ //
>+ // Ignore leading Zeros after the spaces
>+ //
>+ while (*String == L'0') {
>+ String++;
>+ }
>+
>+ if (InternalCharToUpper (*String) == L'X') {
>+ if (*(String - 1) != L'0') {
>+ *Data = 0;
>+ return RETURN_SUCCESS;
>+ }
>+ //
>+ // Skip the 'X'
>+ //
>+ String++;
>+ }
>+
>+ *Data = 0;
>+
>+ while (InternalIsHexaDecimalDigitCharacter (*String)) {
>+ //
>+ // If the number represented by String overflows according to the range
>+ // defined by UINTN, then MAX_UINTN is stored in *Data and
>+ // RETURN_UNSUPPORTED is returned.
>+ //
>+ if (*Data > ((MAX_UINTN - InternalHexCharToUintn (*String)) >> 4)) {
>+ *Data = MAX_UINTN;
>+ if (EndPointer != NULL) {
>+ *EndPointer = (CHAR16 *) String;
>+ }
>+ return RETURN_UNSUPPORTED;
>+ }
>+
>+ *Data = (*Data << 4) + InternalHexCharToUintn (*String);
>+ String++;
>+ }
>+
>+ if (EndPointer != NULL) {
>+ *EndPointer = (CHAR16 *) String;
>+ }
>+ return RETURN_SUCCESS;
>+}
>+RETURN_STATUS
>+StrHexToUint64S (
>+ CONST CHAR16 *String,
>+ CHAR16 **EndPointer, OPTIONAL
>+ UINT64 *Data
>+ )
>+{
>+ ASSERT (((UINTN) String & BIT0) == 0);
>+
>+ //
>+ // 1. Neither String nor Data shall be a null pointer.
>+ //
>+ SAFE_STRING_CONSTRAINT_CHECK ((String != NULL),
>RETURN_INVALID_PARAMETER);
>+ SAFE_STRING_CONSTRAINT_CHECK ((Data != NULL),
>RETURN_INVALID_PARAMETER);
>+
>+ //
>+ // 2. The length of String shall not be greater than RSIZE_MAX.
>+ //
>+ if (RSIZE_MAX != 0) {
>+ SAFE_STRING_CONSTRAINT_CHECK ((StrnLenS (String, RSIZE_MAX + 1) <=
>RSIZE_MAX), RETURN_INVALID_PARAMETER);
>+ }
>+
>+ if (EndPointer != NULL) {
>+ *EndPointer = (CHAR16 *) String;
>+ }
>+
>+ //
>+ // Ignore the pad spaces (space or tab)
>+ //
>+ while ((*String == L' ') || (*String == L'\t')) {
>+ String++;
>+ }
>+
>+ //
>+ // Ignore leading Zeros after the spaces
>+ //
>+ while (*String == L'0') {
>+ String++;
>+ }
>+
>+ if (InternalCharToUpper (*String) == L'X') {
>+ if (*(String - 1) != L'0') {
>+ *Data = 0;
>+ return RETURN_SUCCESS;
>+ }
>+ //
>+ // Skip the 'X'
>+ //
>+ String++;
>+ }
>+
>+ *Data = 0;
>+
>+ while (InternalIsHexaDecimalDigitCharacter (*String)) {
>+ //
>+ // If the number represented by String overflows according to the range
>+ // defined by UINT64, then MAX_UINT64 is stored in *Data and
>+ // RETURN_UNSUPPORTED is returned.
>+ //
>+ if (*Data > ((MAX_UINT64 - InternalHexCharToUintn (*String))>>4)) {
>+ *Data = MAX_UINT64;
>+ if (EndPointer != NULL) {
>+ *EndPointer = (CHAR16 *) String;
>+ }
>+ return RETURN_UNSUPPORTED;
>+ }
>+
>+ *Data = ((*Data) << 4) + InternalHexCharToUintn (*String);
>+ String++;
>+ }
>+
>+ if (EndPointer != NULL) {
>+ *EndPointer = (CHAR16 *) String;
>+ }
>+ return RETURN_SUCCESS;
>+}
>+
>+UINT64
>+StrDecimalToUint64 (
>+ CONST CHAR16 *String
>+ )
>+{
>+ UINT64 Result;
>+
>+ StrDecimalToUint64S (String, (CHAR16 **) NULL, &Result);
>+ return Result;
>+}
>+
>+
>+UINT64
>+StrHexToUint64 (
>+ CONST CHAR16 *String
>+ )
>+{
>+ UINT64 Result;
>+
>+ StrHexToUint64S (String, (CHAR16 **) NULL, &Result);
>+ return Result;
>+}
>+
>+UINTN
>+StrDecimalToUintn (
>+ CONST CHAR16 *String
>+ )
>+{
>+ UINTN Result;
>+
>+ StrDecimalToUintnS (String, (CHAR16 **) NULL, &Result);
>+ return Result;
>+}
>+
>+UINTN
>+StrHexToUintn (
>+ CONST CHAR16 *String
>+ )
>+{
>+ UINTN Result;
>+
>+ StrHexToUintnS (String, (CHAR16 **) NULL, &Result);
>+ return Result;
>+}
>+
>+UINTN
>+StrSize (
>+ CONST CHAR16 *String
>+ )
>+{
>+ return (StrLen (String) + 1) * sizeof (*String);
>+}
>+
>+
>+UINT64
>+ReadUnaligned64 (
>+ CONST UINT64 *Buffer
>+ )
>+{
>+ ASSERT (Buffer != NULL);
>+
>+ return *Buffer;
>+}
>+
>+UINT64
>+WriteUnaligned64 (
>+ UINT64 *Buffer,
>+ UINT64 Value
>+ )
>+{
>+ ASSERT (Buffer != NULL);
>+
>+ return *Buffer = Value;
>+}
>+
>+
>+EFI_GUID *
>+CopyGuid (
>+ EFI_GUID *DestinationGuid,
>+ CONST EFI_GUID *SourceGuid
>+ )
>+{
>+ WriteUnaligned64 (
>+ (UINT64*)DestinationGuid,
>+ ReadUnaligned64 ((CONST UINT64*)SourceGuid)
>+ );
>+ WriteUnaligned64 (
>+ (UINT64*)DestinationGuid + 1,
>+ ReadUnaligned64 ((CONST UINT64*)SourceGuid + 1)
>+ );
>+ return DestinationGuid;
>+}
>+
>+UINT16
>+SwapBytes16 (
>+ UINT16 Value
>+ )
>+{
>+ return (UINT16) ((Value<< 8) | (Value>> 8));
>+}
>+
>+
>+UINT32
>+SwapBytes32 (
>+ UINT32 Value
>+ )
>+{
>+ UINT32 LowerBytes;
>+ UINT32 HigherBytes;
>+
>+ LowerBytes = (UINT32) SwapBytes16 ((UINT16) Value);
>+ HigherBytes = (UINT32) SwapBytes16 ((UINT16) (Value >> 16));
>+ return (LowerBytes << 16 | HigherBytes);
>+}
>+
>+BOOLEAN
>+InternalIsDecimalDigitCharacter (
>+ CHAR16 Char
>+ )
>+{
>+ return (BOOLEAN) (Char >= L'0' && Char <= L'9');
>+}
>+
>+VOID *
>+InternalAllocateCopyPool (
>+ UINTN AllocationSize,
>+ CONST VOID *Buffer
>+ )
>+{
>+ VOID *Memory;
>+
>+ ASSERT (Buffer != NULL);
>+ ASSERT (AllocationSize <= (MAX_ADDRESS - (UINTN) Buffer + 1));
>+
>+ Memory = malloc (AllocationSize);
>+ if (Memory != NULL) {
>+ Memory = memcpy (Memory, Buffer, AllocationSize);
>+ }
>+ return Memory;
>+}
>+
>+BOOLEAN
>+InternalIsHexaDecimalDigitCharacter (
>+ CHAR16 Char
>+ )
>+{
>+
>+ return (BOOLEAN) (InternalIsDecimalDigitCharacter (Char) ||
>+ (Char >= L'A' && Char <= L'F') ||
>+ (Char >= L'a' && Char <= L'f'));
>+}
>+
>+UINTN
>+InternalHexCharToUintn (
>+ CHAR16 Char
>+ )
>+{
>+ if (InternalIsDecimalDigitCharacter (Char)) {
>+ return Char - L'0';
>+ }
>+
>+ return (10 + InternalCharToUpper (Char) - L'A');
>+}
>+
>+
>+/**
>+ Convert a Null-terminated Unicode hexadecimal string to a byte array.
>+
>+ This function outputs a byte array by interpreting the contents of
>+ the Unicode string specified by String in hexadecimal format. The format of
>+ the input Unicode string String is:
>+
>+ [XX]*
>+
>+ X is a hexadecimal digit character in the range [0-9], [a-f] and [A-F].
>+ The function decodes every two hexadecimal digit characters as one byte.
>The
>+ decoding stops after Length of characters and outputs Buffer containing
>+ (Length / 2) bytes.
>+
>+ If String is not aligned in a 16-bit boundary, then ASSERT().
>+
>+ If String is NULL, then ASSERT().
>+
>+ If Buffer is NULL, then ASSERT().
>+
>+ If Length is not multiple of 2, then ASSERT().
>+
>+ If PcdMaximumUnicodeStringLength is not zero and Length is greater than
>+ PcdMaximumUnicodeStringLength, then ASSERT().
>+
>+ If MaxBufferSize is less than (Length / 2), then ASSERT().
>+
>+ @param String Pointer to a Null-terminated Unicode string.
>+ @param Length The number of Unicode characters to decode.
>+ @param Buffer Pointer to the converted bytes array.
>+ @param MaxBufferSize The maximum size of Buffer.
>+
>+ @retval RETURN_SUCCESS Buffer is translated from String.
>+ @retval RETURN_INVALID_PARAMETER If String is NULL.
>+ If Data is NULL.
>+ If Length is not multiple of 2.
>+ If PcdMaximumUnicodeStringLength is not zero,
>+ and Length is greater than
>+ PcdMaximumUnicodeStringLength.
>+ @retval RETURN_UNSUPPORTED If Length of characters from String
>contain
>+ a character that is not valid hexadecimal
>+ digit characters, or a Null-terminator.
>+ @retval RETURN_BUFFER_TOO_SMALL If MaxBufferSize is less than
>(Length / 2).
>+**/
>+RETURN_STATUS
>+StrHexToBytes (
>+ CONST CHAR16 *String,
>+ UINTN Length,
>+ UINT8 *Buffer,
>+ UINTN MaxBufferSize
>+ )
>+{
>+ UINTN Index;
>+
>+ ASSERT (((UINTN) String & BIT0) == 0);
>+
>+ //
>+ // 1. None of String or Buffer shall be a null pointer.
>+ //
>+ SAFE_STRING_CONSTRAINT_CHECK ((String != NULL),
>RETURN_INVALID_PARAMETER);
>+ SAFE_STRING_CONSTRAINT_CHECK ((Buffer != NULL),
>RETURN_INVALID_PARAMETER);
>+
>+ //
>+ // 2. Length shall not be greater than RSIZE_MAX.
>+ //
>+ if (RSIZE_MAX != 0) {
>+ SAFE_STRING_CONSTRAINT_CHECK ((Length <= RSIZE_MAX),
>RETURN_INVALID_PARAMETER);
>+ }
>+
>+ //
>+ // 3. Length shall not be odd.
>+ //
>+ SAFE_STRING_CONSTRAINT_CHECK (((Length & BIT0) == 0),
>RETURN_INVALID_PARAMETER);
>+
>+ //
>+ // 4. MaxBufferSize shall equal to or greater than Length / 2.
>+ //
>+ SAFE_STRING_CONSTRAINT_CHECK ((MaxBufferSize >= Length / 2),
>RETURN_BUFFER_TOO_SMALL);
>+
>+ //
>+ // 5. String shall not contains invalid hexadecimal digits.
>+ //
>+ for (Index = 0; Index < Length; Index++) {
>+ if (!InternalIsHexaDecimalDigitCharacter (String[Index])) {
>+ break;
>+ }
>+ }
>+ if (Index != Length) {
>+ return RETURN_UNSUPPORTED;
>+ }
>+
>+ //
>+ // Convert the hex string to bytes.
>+ //
>+ for(Index = 0; Index < Length; Index++) {
>+
>+ //
>+ // For even characters, write the upper nibble for each buffer byte,
>+ // and for even characters, the lower nibble.
>+ //
>+ if ((Index & BIT0) == 0) {
>+ Buffer[Index / 2] = (UINT8) InternalHexCharToUintn (String[Index]) << 4;
>+ } else {
>+ Buffer[Index / 2] |= (UINT8) InternalHexCharToUintn (String[Index]);
>+ }
>+ }
>+ return RETURN_SUCCESS;
>+}
>+
>+/**
>+ Convert a Null-terminated Unicode GUID string to a value of type
>+ EFI_GUID.
>+
>+ This function outputs a GUID value by interpreting the contents of
>+ the Unicode string specified by String. The format of the input
>+ Unicode string String consists of 36 characters, as follows:
>+
>+ aabbccdd-eeff-gghh-iijj-kkllmmnnoopp
>+
>+ The pairs aa - pp are two characters in the range [0-9], [a-f] and
>+ [A-F], with each pair representing a single byte hexadecimal value.
>+
>+ The mapping between String and the EFI_GUID structure is as follows:
>+ aa Data1[24:31]
>+ bb Data1[16:23]
>+ cc Data1[8:15]
>+ dd Data1[0:7]
>+ ee Data2[8:15]
>+ ff Data2[0:7]
>+ gg Data3[8:15]
>+ hh Data3[0:7]
>+ ii Data4[0:7]
>+ jj Data4[8:15]
>+ kk Data4[16:23]
>+ ll Data4[24:31]
>+ mm Data4[32:39]
>+ nn Data4[40:47]
>+ oo Data4[48:55]
>+ pp Data4[56:63]
>+
>+ If String is NULL, then ASSERT().
>+ If Guid is NULL, then ASSERT().
>+ If String is not aligned in a 16-bit boundary, then ASSERT().
>+
>+ @param String Pointer to a Null-terminated Unicode string.
>+ @param Guid Pointer to the converted GUID.
>+
>+ @retval RETURN_SUCCESS Guid is translated from String.
>+ @retval RETURN_INVALID_PARAMETER If String is NULL.
>+ If Data is NULL.
>+ @retval RETURN_UNSUPPORTED If String is not as the above format.
>+
>+**/
>+RETURN_STATUS
>+StrToGuid (
>+ CONST CHAR16 *String,
>+ EFI_GUID *Guid
>+ )
>+{
>+ RETURN_STATUS Status;
>+ EFI_GUID LocalGuid;
>+
>+ ASSERT (((UINTN) String & BIT0) == 0);
>+
>+ //
>+ // 1. None of String or Guid shall be a null pointer.
>+ //
>+ SAFE_STRING_CONSTRAINT_CHECK ((String != NULL),
>RETURN_INVALID_PARAMETER);
>+ SAFE_STRING_CONSTRAINT_CHECK ((Guid != NULL),
>RETURN_INVALID_PARAMETER);
>+
>+ //
>+ // Get aabbccdd in big-endian.
>+ //
>+ Status = StrHexToBytes (String, 2 * sizeof (LocalGuid.Data1), (UINT8 *)
>&LocalGuid.Data1, sizeof (LocalGuid.Data1));
>+ if (RETURN_ERROR (Status) || String[2 * sizeof (LocalGuid.Data1)] != L'-') {
>+ return RETURN_UNSUPPORTED;
>+ }
>+ //
>+ // Convert big-endian to little-endian.
>+ //
>+ LocalGuid.Data1 = SwapBytes32 (LocalGuid.Data1);
>+ String += 2 * sizeof (LocalGuid.Data1) + 1;
>+
>+ //
>+ // Get eeff in big-endian.
>+ //
>+ Status = StrHexToBytes (String, 2 * sizeof (LocalGuid.Data2), (UINT8 *)
>&LocalGuid.Data2, sizeof (LocalGuid.Data2));
>+ if (RETURN_ERROR (Status) || String[2 * sizeof (LocalGuid.Data2)] != L'-') {
>+ return RETURN_UNSUPPORTED;
>+ }
>+ //
>+ // Convert big-endian to little-endian.
>+ //
>+ LocalGuid.Data2 = SwapBytes16 (LocalGuid.Data2);
>+ String += 2 * sizeof (LocalGuid.Data2) + 1;
>+
>+ //
>+ // Get gghh in big-endian.
>+ //
>+ Status = StrHexToBytes (String, 2 * sizeof (LocalGuid.Data3), (UINT8 *)
>&LocalGuid.Data3, sizeof (LocalGuid.Data3));
>+ if (RETURN_ERROR (Status) || String[2 * sizeof (LocalGuid.Data3)] != L'-') {
>+ return RETURN_UNSUPPORTED;
>+ }
>+ //
>+ // Convert big-endian to little-endian.
>+ //
>+ LocalGuid.Data3 = SwapBytes16 (LocalGuid.Data3);
>+ String += 2 * sizeof (LocalGuid.Data3) + 1;
>+
>+ //
>+ // Get iijj.
>+ //
>+ Status = StrHexToBytes (String, 2 * 2, &LocalGuid.Data4[0], 2);
>+ if (RETURN_ERROR (Status) || String[2 * 2] != L'-') {
>+ return RETURN_UNSUPPORTED;
>+ }
>+ String += 2 * 2 + 1;
>+
>+ //
>+ // Get kkllmmnnoopp.
>+ //
>+ Status = StrHexToBytes (String, 2 * 6, &LocalGuid.Data4[2], 6);
>+ if (RETURN_ERROR (Status)) {
>+ return RETURN_UNSUPPORTED;
>+ }
>+
>+ CopyGuid (Guid, &LocalGuid);
>+ return RETURN_SUCCESS;
>+}
>+
>+/**
>+ Compares up to a specified length the contents of two Null-terminated
>Unicode strings,
>+ and returns the difference between the first mismatched Unicode
>characters.
>+
>+ This function compares the Null-terminated Unicode string FirstString to the
>+ Null-terminated Unicode string SecondString. At most, Length Unicode
>+ characters will be compared. If Length is 0, then 0 is returned. If
>+ FirstString is identical to SecondString, then 0 is returned. Otherwise, the
>+ value returned is the first mismatched Unicode character in SecondString
>+ subtracted from the first mismatched Unicode character in FirstString.
>+
>+ If Length > 0 and FirstString is NULL, then ASSERT().
>+ If Length > 0 and FirstString is not aligned on a 16-bit boundary, then
>ASSERT().
>+ If Length > 0 and SecondString is NULL, then ASSERT().
>+ If Length > 0 and SecondString is not aligned on a 16-bit boundary, then
>ASSERT().
>+ If PcdMaximumUnicodeStringLength is not zero, and Length is greater than
>+ PcdMaximumUnicodeStringLength, then ASSERT().
>+ If PcdMaximumUnicodeStringLength is not zero, and FirstString contains
>more than
>+ PcdMaximumUnicodeStringLength Unicode characters, not including the
>Null-terminator,
>+ then ASSERT().
>+ If PcdMaximumUnicodeStringLength is not zero, and SecondString contains
>more than
>+ PcdMaximumUnicodeStringLength Unicode characters, not including the
>Null-terminator,
>+ then ASSERT().
>+
>+ @param FirstString A pointer to a Null-terminated Unicode string.
>+ @param SecondString A pointer to a Null-terminated Unicode string.
>+ @param Length The maximum number of Unicode characters to
>compare.
>+
>+ @retval 0 FirstString is identical to SecondString.
>+ @return others FirstString is not identical to SecondString.
>+
>+**/
>+INTN
>+StrnCmp (
>+ CONST CHAR16 *FirstString,
>+ CONST CHAR16 *SecondString,
>+ UINTN Length
>+ )
>+{
>+ if (Length == 0) {
>+ return 0;
>+ }
>+
>+ //
>+ // ASSERT both strings are less long than PcdMaximumUnicodeStringLength.
>+ // Length tests are performed inside StrLen().
>+ //
>+ ASSERT (StrSize (FirstString) != 0);
>+ ASSERT (StrSize (SecondString) != 0);
>+
>+ while ((*FirstString != L'\0') &&
>+ (*SecondString != L'\0') &&
>+ (*FirstString == *SecondString) &&
>+ (Length > 1)) {
>+ FirstString++;
>+ SecondString++;
>+ Length--;
>+ }
>+
>+ return *FirstString - *SecondString;
>+}
>+
>+VOID *
>+AllocateCopyPool (
>+ UINTN AllocationSize,
>+ CONST VOID *Buffer
>+ )
>+{
>+ return InternalAllocateCopyPool (AllocationSize, Buffer);
>+}
>+
>+INTN
>+StrCmp (
>+ CONST CHAR16 *FirstString,
>+ CONST CHAR16 *SecondString
>+ )
>+{
>+ //
>+ // ASSERT both strings are less long than PcdMaximumUnicodeStringLength
>+ //
>+ ASSERT (StrSize (FirstString) != 0);
>+ ASSERT (StrSize (SecondString) != 0);
>+
>+ while ((*FirstString != L'\0') && (*FirstString == *SecondString)) {
>+ FirstString++;
>+ SecondString++;
>+ }
>+ return *FirstString - *SecondString;
>+}
>+
>+UINT64
>+SwapBytes64 (
>+ UINT64 Value
>+ )
>+{
>+ return InternalMathSwapBytes64 (Value);
>+}
>+
>+UINT64
>+InternalMathSwapBytes64 (
>+ UINT64 Operand
>+ )
>+{
>+ UINT64 LowerBytes;
>+ UINT64 HigherBytes;
>+
>+ LowerBytes = (UINT64) SwapBytes32 ((UINT32) Operand);
>+ HigherBytes = (UINT64) SwapBytes32 ((UINT32) (Operand >> 32));
>+
>+ return (LowerBytes << 32 | HigherBytes);
>+}
>+
>+RETURN_STATUS
>+StrToIpv4Address (
>+ CONST CHAR16 *String,
>+ CHAR16 **EndPointer,
>+ EFI_IPv4_ADDRESS *Address,
>+ UINT8 *PrefixLength
>+ )
>+{
>+ RETURN_STATUS Status;
>+ UINTN AddressIndex;
>+ UINTN Uintn;
>+ EFI_IPv4_ADDRESS LocalAddress;
>+ UINT8 LocalPrefixLength;
>+ CHAR16 *Pointer;
>+
>+ LocalPrefixLength = MAX_UINT8;
>+ LocalAddress.Addr[0] = 0;
>+
>+ ASSERT (((UINTN) String & BIT0) == 0);
>+
>+ //
>+ // 1. None of String or Guid shall be a null pointer.
>+ //
>+ SAFE_STRING_CONSTRAINT_CHECK ((String != NULL),
>RETURN_INVALID_PARAMETER);
>+ SAFE_STRING_CONSTRAINT_CHECK ((Address != NULL),
>RETURN_INVALID_PARAMETER);
>+
>+ for (Pointer = (CHAR16 *) String, AddressIndex = 0; AddressIndex <
>ARRAY_SIZE (Address->Addr) + 1;) {
>+ if (!InternalIsDecimalDigitCharacter (*Pointer)) {
>+ //
>+ // D or P contains invalid characters.
>+ //
>+ break;
>+ }
>+
>+ //
>+ // Get D or P.
>+ //
>+ Status = StrDecimalToUintnS ((CONST CHAR16 *) Pointer, &Pointer,
>&Uintn);
>+ if (RETURN_ERROR (Status)) {
>+ return RETURN_UNSUPPORTED;
>+ }
>+ if (AddressIndex == ARRAY_SIZE (Address->Addr)) {
>+ //
>+ // It's P.
>+ //
>+ if (Uintn > 32) {
>+ return RETURN_UNSUPPORTED;
>+ }
>+ LocalPrefixLength = (UINT8) Uintn;
>+ } else {
>+ //
>+ // It's D.
>+ //
>+ if (Uintn > MAX_UINT8) {
>+ return RETURN_UNSUPPORTED;
>+ }
>+ LocalAddress.Addr[AddressIndex] = (UINT8) Uintn;
>+ AddressIndex++;
>+ }
>+
>+ //
>+ // Check the '.' or '/', depending on the AddressIndex.
>+ //
>+ if (AddressIndex == ARRAY_SIZE (Address->Addr)) {
>+ if (*Pointer == L'/') {
>+ //
>+ // '/P' is in the String.
>+ // Skip "/" and get P in next loop.
>+ //
>+ Pointer++;
>+ } else {
>+ //
>+ // '/P' is not in the String.
>+ //
>+ break;
>+ }
>+ } else if (AddressIndex < ARRAY_SIZE (Address->Addr)) {
>+ if (*Pointer == L'.') {
>+ //
>+ // D should be followed by '.'
>+ //
>+ Pointer++;
>+ } else {
>+ return RETURN_UNSUPPORTED;
>+ }
>+ }
>+ }
>+
>+ if (AddressIndex < ARRAY_SIZE (Address->Addr)) {
>+ return RETURN_UNSUPPORTED;
>+ }
>+
>+ memcpy (Address, &LocalAddress, sizeof (*Address));
>+ if (PrefixLength != NULL) {
>+ *PrefixLength = LocalPrefixLength;
>+ }
>+ if (EndPointer != NULL) {
>+ *EndPointer = Pointer;
>+ }
>+
>+ return RETURN_SUCCESS;
>+}
>+
>+RETURN_STATUS
>+StrToIpv6Address (
>+ CONST CHAR16 *String,
>+ CHAR16 **EndPointer,
>+ EFI_IPv6_ADDRESS *Address,
>+ UINT8 *PrefixLength
>+ )
>+{
>+ RETURN_STATUS Status;
>+ UINTN AddressIndex;
>+ UINTN Uintn;
>+ EFI_IPv6_ADDRESS LocalAddress;
>+ UINT8 LocalPrefixLength;
>+ CONST CHAR16 *Pointer;
>+ CHAR16 *End;
>+ UINTN CompressStart;
>+ BOOLEAN ExpectPrefix;
>+
>+ LocalPrefixLength = MAX_UINT8;
>+ CompressStart = ARRAY_SIZE (Address->Addr);
>+ ExpectPrefix = FALSE;
>+
>+ ASSERT (((UINTN) String & BIT0) == 0);
>+
>+ //
>+ // 1. None of String or Guid shall be a null pointer.
>+ //
>+ SAFE_STRING_CONSTRAINT_CHECK ((String != NULL),
>RETURN_INVALID_PARAMETER);
>+ SAFE_STRING_CONSTRAINT_CHECK ((Address != NULL),
>RETURN_INVALID_PARAMETER);
>+
>+ for (Pointer = String, AddressIndex = 0; AddressIndex < ARRAY_SIZE
>(Address->Addr) + 1;) {
>+ if (!InternalIsHexaDecimalDigitCharacter (*Pointer)) {
>+ if (*Pointer != L':') {
>+ //
>+ // ":" or "/" should be followed by digit characters.
>+ //
>+ return RETURN_UNSUPPORTED;
>+ }
>+
>+ //
>+ // Meet second ":" after previous ":" or "/"
>+ // or meet first ":" in the beginning of String.
>+ //
>+ if (ExpectPrefix) {
>+ //
>+ // ":" shall not be after "/"
>+ //
>+ return RETURN_UNSUPPORTED;
>+ }
>+
>+ if (CompressStart != ARRAY_SIZE (Address->Addr) || AddressIndex ==
>ARRAY_SIZE (Address->Addr)) {
>+ //
>+ // "::" can only appear once.
>+ // "::" can only appear when address is not full length.
>+ //
>+ return RETURN_UNSUPPORTED;
>+ } else {
>+ //
>+ // Remember the start of zero compressing.
>+ //
>+ CompressStart = AddressIndex;
>+ Pointer++;
>+
>+ if (CompressStart == 0) {
>+ if (*Pointer != L':') {
>+ //
>+ // Single ":" shall not be in the beginning of String.
>+ //
>+ return RETURN_UNSUPPORTED;
>+ }
>+ Pointer++;
>+ }
>+ }
>+ }
>+
>+ if (!InternalIsHexaDecimalDigitCharacter (*Pointer)) {
>+ if (*Pointer == L'/') {
>+ //
>+ // Might be optional "/P" after "::".
>+ //
>+ if (CompressStart != AddressIndex) {
>+ return RETURN_UNSUPPORTED;
>+ }
>+ } else {
>+ break;
>+ }
>+ } else {
>+ if (!ExpectPrefix) {
>+ //
>+ // Get X.
>+ //
>+ Status = StrHexToUintnS (Pointer, &End, &Uintn);
>+ if (RETURN_ERROR (Status) || End - Pointer > 4) {
>+ //
>+ // Number of hexadecimal digit characters is no more than 4.
>+ //
>+ return RETURN_UNSUPPORTED;
>+ }
>+ Pointer = End;
>+ //
>+ // Uintn won't exceed MAX_UINT16 if number of hexadecimal digit
>characters is no more than 4.
>+ //
>+ ASSERT (AddressIndex + 1 < ARRAY_SIZE (Address->Addr));
>+ LocalAddress.Addr[AddressIndex] = (UINT8) ((UINT16) Uintn >> 8);
>+ LocalAddress.Addr[AddressIndex + 1] = (UINT8) Uintn;
>+ AddressIndex += 2;
>+ } else {
>+ //
>+ // Get P, then exit the loop.
>+ //
>+ Status = StrDecimalToUintnS (Pointer, &End, &Uintn);
>+ if (RETURN_ERROR (Status) || End == Pointer || Uintn > 128) {
>+ //
>+ // Prefix length should not exceed 128.
>+ //
>+ return RETURN_UNSUPPORTED;
>+ }
>+ LocalPrefixLength = (UINT8) Uintn;
>+ Pointer = End;
>+ break;
>+ }
>+ }
>+
>+ //
>+ // Skip ':' or "/"
>+ //
>+ if (*Pointer == L'/') {
>+ ExpectPrefix = TRUE;
>+ } else if (*Pointer == L':') {
>+ if (AddressIndex == ARRAY_SIZE (Address->Addr)) {
>+ //
>+ // Meet additional ":" after all 8 16-bit address
>+ //
>+ break;
>+ }
>+ } else {
>+ //
>+ // Meet other character that is not "/" or ":" after all 8 16-bit address
>+ //
>+ break;
>+ }
>+ Pointer++;
>+ }
>+
>+ if ((AddressIndex == ARRAY_SIZE (Address->Addr) && CompressStart !=
>ARRAY_SIZE (Address->Addr)) ||
>+ (AddressIndex != ARRAY_SIZE (Address->Addr) && CompressStart ==
>ARRAY_SIZE (Address->Addr))
>+ ) {
>+ //
>+ // Full length of address shall not have compressing zeros.
>+ // Non-full length of address shall have compressing zeros.
>+ //
>+ return RETURN_UNSUPPORTED;
>+ }
>+ memcpy (&Address->Addr[0], &LocalAddress.Addr[0], CompressStart);
>+ memset (&Address->Addr[CompressStart], 0, ARRAY_SIZE (Address->Addr)
>- AddressIndex);
>+ if (AddressIndex > CompressStart) {
>+ memcpy (
>+ &Address->Addr[CompressStart + ARRAY_SIZE (Address->Addr) -
>AddressIndex],
>+ &LocalAddress.Addr[CompressStart],
>+ AddressIndex - CompressStart
>+ );
>+ }
>+
>+ if (PrefixLength != NULL) {
>+ *PrefixLength = LocalPrefixLength;
>+ }
>+ if (EndPointer != NULL) {
>+ *EndPointer = (CHAR16 *) Pointer;
>+ }
>+
>+ return RETURN_SUCCESS;
>+}
>+
>+
>+RETURN_STATUS
>+UnicodeStrToAsciiStrS (
>+ CONST CHAR16 *Source,
>+ CHAR8 *Destination,
>+ UINTN DestMax
>+ )
>+{
>+ UINTN SourceLen;
>+
>+ ASSERT (((UINTN) Source & BIT0) == 0);
>+
>+ //
>+ // 1. Neither Destination nor Source shall be a null pointer.
>+ //
>+ SAFE_STRING_CONSTRAINT_CHECK ((Destination != NULL),
>RETURN_INVALID_PARAMETER);
>+ SAFE_STRING_CONSTRAINT_CHECK ((Source != NULL),
>RETURN_INVALID_PARAMETER);
>+
>+ //
>+ // 2. DestMax shall not be greater than ASCII_RSIZE_MAX or RSIZE_MAX.
>+ //
>+ if (ASCII_RSIZE_MAX != 0) {
>+ SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= ASCII_RSIZE_MAX),
>RETURN_INVALID_PARAMETER);
>+ }
>+ if (RSIZE_MAX != 0) {
>+ SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= RSIZE_MAX),
>RETURN_INVALID_PARAMETER);
>+ }
>+
>+ //
>+ // 3. DestMax shall not equal zero.
>+ //
>+ SAFE_STRING_CONSTRAINT_CHECK ((DestMax != 0),
>RETURN_INVALID_PARAMETER);
>+
>+ //
>+ // 4. DestMax shall be greater than StrnLenS (Source, DestMax).
>+ //
>+ SourceLen = StrnLenS (Source, DestMax);
>+ SAFE_STRING_CONSTRAINT_CHECK ((DestMax > SourceLen),
>RETURN_BUFFER_TOO_SMALL);
>+
>+ //
>+ // 5. Copying shall not take place between objects that overlap.
>+ //
>+ SAFE_STRING_CONSTRAINT_CHECK (!InternalSafeStringIsOverlap
>(Destination, DestMax, (VOID *)Source, (SourceLen + 1) * sizeof(CHAR16)),
>RETURN_ACCESS_DENIED);
>+
>+ //
>+ // convert string
>+ //
>+ while (*Source != '\0') {
>+ //
>+ // If any Unicode characters in Source contain
>+ // non-zero value in the upper 8 bits, then ASSERT().
>+ //
>+ ASSERT (*Source < 0x100);
>+ *(Destination++) = (CHAR8) *(Source++);
>+ }
>+ *Destination = '\0';
>+
>+ return RETURN_SUCCESS;
>+}
>+
>+RETURN_STATUS
>+StrCpyS (
>+ CHAR16 *Destination,
>+ UINTN DestMax,
>+ CONST CHAR16 *Source
>+ )
>+{
>+ UINTN SourceLen;
>+
>+ ASSERT (((UINTN) Destination & BIT0) == 0);
>+ ASSERT (((UINTN) Source & BIT0) == 0);
>+
>+ //
>+ // 1. Neither Destination nor Source shall be a null pointer.
>+ //
>+ SAFE_STRING_CONSTRAINT_CHECK ((Destination != NULL),
>RETURN_INVALID_PARAMETER);
>+ SAFE_STRING_CONSTRAINT_CHECK ((Source != NULL),
>RETURN_INVALID_PARAMETER);
>+
>+ //
>+ // 2. DestMax shall not be greater than RSIZE_MAX.
>+ //
>+ if (RSIZE_MAX != 0) {
>+ SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= RSIZE_MAX),
>RETURN_INVALID_PARAMETER);
>+ }
>+
>+ //
>+ // 3. DestMax shall not equal zero.
>+ //
>+ SAFE_STRING_CONSTRAINT_CHECK ((DestMax != 0),
>RETURN_INVALID_PARAMETER);
>+
>+ //
>+ // 4. DestMax shall be greater than StrnLenS(Source, DestMax).
>+ //
>+ SourceLen = StrnLenS (Source, DestMax);
>+ SAFE_STRING_CONSTRAINT_CHECK ((DestMax > SourceLen),
>RETURN_BUFFER_TOO_SMALL);
>+
>+ //
>+ // 5. Copying shall not take place between objects that overlap.
>+ //
>+ SAFE_STRING_CONSTRAINT_CHECK (InternalSafeStringNoStrOverlap
>(Destination, DestMax, (CHAR16 *)Source, SourceLen + 1),
>RETURN_ACCESS_DENIED);
>+
>+ //
>+ // The StrCpyS function copies the string pointed to by Source (including the
>terminating
>+ // null character) into the array pointed to by Destination.
>+ //
>+ while (*Source != 0) {
>+ *(Destination++) = *(Source++);
>+ }
>+ *Destination = 0;
>+
>+ return RETURN_SUCCESS;
>+}
>+
>+VOID *
>+AllocateZeroPool (
>+ UINTN AllocationSize
>+ )
>+{
>+ VOID * Memory;
>+ Memory = malloc(AllocationSize);
>+ ASSERT (Memory != NULL);
>+ if (Memory == NULL) {
>+ fprintf(stderr, "Not memory for malloc\n");
>+ }
>+ memset(Memory, 0, AllocationSize);
>+ return Memory;
>+}
>+
>+VOID *
>+AllocatePool (
>+ UINTN AllocationSize
>+ )
>+{
>+ return InternalAllocatePool (AllocationSize);
>+}
>+
>+UINT16
>+WriteUnaligned16 (
>+ UINT16 *Buffer,
>+ UINT16 Value
>+ )
>+{
>+ ASSERT (Buffer != NULL);
>+
>+ return *Buffer = Value;
>+}
>+
>+UINT16
>+ReadUnaligned16 (
>+ CONST UINT16 *Buffer
>+ )
>+{
>+ ASSERT (Buffer != NULL);
>+
>+ return *Buffer;
>+}
>diff --git a/BaseTools/Source/C/DevicePath/DevicePathUtilities.h
>b/BaseTools/Source/C/DevicePath/DevicePathUtilities.h
>new file mode 100644
>index 0000000..418615f
>--- /dev/null
>+++ b/BaseTools/Source/C/DevicePath/DevicePathUtilities.h
>@@ -0,0 +1,555 @@
>+/** @file
>+ EFI_DEVICE_PATH_UTILITIES_PROTOCOL as defined in UEFI 2.0.
>+ Use to create and manipulate device paths and device nodes.
>+
>+ Copyright (c) 2017, Intel Corporation. All rights reserved.<BR>
>+ This program and the accompanying materials
>+ are licensed and made available under the terms and conditions of the BSD
>License
>+ which accompanies this distribution. The full text of the license may be
>found at
>+ http://opensource.org/licenses/bsd-license.php
>+
>+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+**/
>+
>+#ifndef __DEVICE_PATH_UTILITIES_H__
>+#define __DEVICE_PATH_UTILITIES_H__
>+
>+///
>+/// Device Path Utilities protocol
>+///
>+#define EFI_DEVICE_PATH_UTILITIES_GUID \
>+ { \
>+ 0x379be4e, 0xd706, 0x437d, {0xb0, 0x37, 0xed, 0xb8, 0x2f, 0xb7, 0x72,
>0xa4 } \
>+ }
>+
>+/**
>+ Returns the size of the device path, in bytes.
>+
>+ @param DevicePath Points to the start of the EFI device path.
>+
>+ @return Size Size of the specified device path, in bytes, including the end-
>of-path tag.
>+ @retval 0 DevicePath is NULL
>+
>+**/
>+typedef
>+UINTN
>+( *EFI_DEVICE_PATH_UTILS_GET_DEVICE_PATH_SIZE)(
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath
>+ );
>+
>+
>+/**
>+ Create a duplicate of the specified path.
>+
>+ @param DevicePath Points to the source EFI device path.
>+
>+ @retval Pointer A pointer to the duplicate device path.
>+ @retval NULL insufficient memory or DevicePath is NULL
>+
>+**/
>+typedef
>+EFI_DEVICE_PATH_PROTOCOL*
>+( *EFI_DEVICE_PATH_UTILS_DUP_DEVICE_PATH)(
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath
>+ );
>+
>+/**
>+ Create a new path by appending the second device path to the first.
>+ If Src1 is NULL and Src2 is non-NULL, then a duplicate of Src2 is returned.
>+ If Src1 is non-NULL and Src2 is NULL, then a duplicate of Src1 is returned.
>+ If Src1 and Src2 are both NULL, then a copy of an end-of-device-path is
>returned.
>+
>+ @param Src1 Points to the first device path.
>+ @param Src2 Points to the second device path.
>+
>+ @retval Pointer A pointer to the newly created device path.
>+ @retval NULL Memory could not be allocated
>+
>+**/
>+typedef
>+EFI_DEVICE_PATH_PROTOCOL*
>+( *EFI_DEVICE_PATH_UTILS_APPEND_PATH)(
>+ CONST EFI_DEVICE_PATH_PROTOCOL *Src1,
>+ CONST EFI_DEVICE_PATH_PROTOCOL *Src2
>+ );
>+
>+/**
>+ Creates a new path by appending the device node to the device path.
>+ If DeviceNode is NULL then a copy of DevicePath is returned.
>+ If DevicePath is NULL then a copy of DeviceNode, followed by an end-of-
>device path device node is returned.
>+ If both DeviceNode and DevicePath are NULL then a copy of an end-of-
>device-path device node is returned.
>+
>+ @param DevicePath Points to the device path.
>+ @param DeviceNode Points to the device node.
>+
>+ @retval Pointer A pointer to the allocated device node.
>+ @retval NULL There was insufficient memory.
>+
>+**/
>+typedef
>+EFI_DEVICE_PATH_PROTOCOL*
>+( *EFI_DEVICE_PATH_UTILS_APPEND_NODE)(
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath,
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DeviceNode
>+ );
>+
>+/**
>+ Creates a new path by appending the specified device path instance to the
>specified device path.
>+
>+ @param DevicePath Points to the device path. If NULL, then ignored.
>+ @param DevicePathInstance Points to the device path instance.
>+
>+ @retval Pointer A pointer to the newly created device path
>+ @retval NULL Memory could not be allocated or DevicePathInstance
>is NULL.
>+
>+**/
>+typedef
>+EFI_DEVICE_PATH_PROTOCOL*
>+( *EFI_DEVICE_PATH_UTILS_APPEND_INSTANCE)(
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath,
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePathInstance
>+ );
>+
>+/**
>+ Creates a copy of the current device path instance and returns a pointer to
>the next device path
>+ instance.
>+
>+ @param DevicePathInstance On input, this holds the pointer to the
>current device path
>+ instance. On output, this holds the pointer to the next
>+ device path instance or NULL if there are no more device
>+ path instances in the device path.
>+ @param DevicePathInstanceSize On output, this holds the size of the
>device path instance,
>+ in bytes or zero, if DevicePathInstance is NULL.
>+ If NULL, then the instance size is not output.
>+
>+ @retval Pointer A pointer to the copy of the current device path
>instance.
>+ @retval NULL DevicePathInstace was NULL on entry or there was
>insufficient memory.
>+
>+**/
>+typedef
>+EFI_DEVICE_PATH_PROTOCOL*
>+( *EFI_DEVICE_PATH_UTILS_GET_NEXT_INSTANCE)(
>+ EFI_DEVICE_PATH_PROTOCOL **DevicePathInstance,
>+ UINTN *DevicePathInstanceSize
>+ );
>+
>+/**
>+ Creates a device node
>+
>+ @param NodeType NodeType is the device node type
>(EFI_DEVICE_PATH.Type) for
>+ the new device node.
>+ @param NodeSubType NodeSubType is the device node sub-type
>+ EFI_DEVICE_PATH.SubType) for the new device node.
>+ @param NodeLength NodeLength is the length of the device node
>+ (EFI_DEVICE_PATH.Length) for the new device node.
>+
>+ @retval Pointer A pointer to the newly created device node.
>+ @retval NULL NodeLength is less than
>+ the size of the header or there was insufficient memory.
>+
>+**/
>+typedef
>+EFI_DEVICE_PATH_PROTOCOL*
>+( *EFI_DEVICE_PATH_UTILS_CREATE_NODE)(
>+ UINT8 NodeType,
>+ UINT8 NodeSubType,
>+ UINT16 NodeLength
>+);
>+
>+/**
>+ Returns whether a device path is multi-instance.
>+
>+ @param DevicePath Points to the device path. If NULL, then ignored.
>+
>+ @retval TRUE The device path has more than one instance
>+ @retval FALSE The device path is empty or contains only a single instance.
>+
>+**/
>+typedef
>+BOOLEAN
>+( *EFI_DEVICE_PATH_UTILS_IS_MULTI_INSTANCE)(
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath
>+ );
>+
>+///
>+/// This protocol is used to creates and manipulates device paths and device
>nodes.
>+///
>+typedef struct {
>+ EFI_DEVICE_PATH_UTILS_GET_DEVICE_PATH_SIZE GetDevicePathSize;
>+ EFI_DEVICE_PATH_UTILS_DUP_DEVICE_PATH DuplicateDevicePath;
>+ EFI_DEVICE_PATH_UTILS_APPEND_PATH AppendDevicePath;
>+ EFI_DEVICE_PATH_UTILS_APPEND_NODE AppendDeviceNode;
>+ EFI_DEVICE_PATH_UTILS_APPEND_INSTANCE
>AppendDevicePathInstance;
>+ EFI_DEVICE_PATH_UTILS_GET_NEXT_INSTANCE
>GetNextDevicePathInstance;
>+ EFI_DEVICE_PATH_UTILS_IS_MULTI_INSTANCE
>IsDevicePathMultiInstance;
>+ EFI_DEVICE_PATH_UTILS_CREATE_NODE CreateDeviceNode;
>+} EFI_DEVICE_PATH_UTILITIES_PROTOCOL;
>+
>+extern EFI_GUID gEfiDevicePathUtilitiesProtocolGuid;
>+
>+UINTN
>+StrLen (
>+ CONST CHAR16 *String
>+ );
>+
>+VOID *
>+AllocateCopyPool (
>+ UINTN AllocationSize,
>+ CONST VOID *Buffer
>+ );
>+
>+INTN
>+StrnCmp (
>+ CONST CHAR16 *FirstString,
>+ CONST CHAR16 *SecondString,
>+ UINTN Length
>+ );
>+
>+RETURN_STATUS
>+StrToGuid (
>+ CONST CHAR16 *String,
>+ EFI_GUID *Guid
>+ );
>+
>+RETURN_STATUS
>+StrHexToBytes (
>+ CONST CHAR16 *String,
>+ UINTN Length,
>+ UINT8 *Buffer,
>+ UINTN MaxBufferSize
>+ );
>+
>+UINTN
>+InternalHexCharToUintn (
>+ CHAR16 Char
>+ );
>+
>+VOID *
>+InternalAllocateCopyPool (
>+ UINTN AllocationSize,
>+ CONST VOID *Buffer
>+ );
>+
>+BOOLEAN
>+InternalIsDecimalDigitCharacter (
>+ CHAR16 Char
>+ );
>+
>+UINT32
>+SwapBytes32 (
>+ UINT32 Value
>+ );
>+
>+UINT16
>+SwapBytes16 (
>+ UINT16 Value
>+ );
>+
>+EFI_GUID *
>+CopyGuid (
>+ EFI_GUID *DestinationGuid,
>+ CONST EFI_GUID *SourceGuid
>+ );
>+
>+UINT64
>+WriteUnaligned64 (
>+ UINT64 *Buffer,
>+ UINT64 Value
>+ );
>+
>+UINT64
>+ReadUnaligned64 (
>+ CONST UINT64 *Buffer
>+ );
>+
>+UINTN
>+StrSize (
>+ CONST CHAR16 *String
>+ );
>+
>+UINTN
>+StrHexToUintn (
>+ CONST CHAR16 *String
>+ );
>+
>+UINTN
>+StrDecimalToUintn (
>+ CONST CHAR16 *String
>+ );
>+
>+UINT64
>+StrHexToUint64 (
>+ CONST CHAR16 *String
>+ );
>+
>+UINT64
>+StrDecimalToUint64 (
>+ CONST CHAR16 *String
>+ );
>+
>+RETURN_STATUS
>+StrHexToUint64S (
>+ CONST CHAR16 *String,
>+ CHAR16 **EndPointer,
>+ UINT64 *Data
>+ );
>+
>+RETURN_STATUS
>+StrHexToUintnS (
>+ CONST CHAR16 *String,
>+ CHAR16 **EndPointer, OPTIONAL
>+ UINTN *Data
>+ );
>+
>+RETURN_STATUS
>+StrDecimalToUint64S (
>+ CONST CHAR16 *String,
>+ CHAR16 **EndPointer, OPTIONAL
>+ UINT64 *Data
>+ );
>+
>+RETURN_STATUS
>+StrDecimalToUintnS (
>+ CONST CHAR16 *String,
>+ CHAR16 **EndPointer, OPTIONAL
>+ UINTN *Data
>+ );
>+
>+VOID *
>+ReallocatePool (
>+ UINTN OldSize,
>+ UINTN NewSize,
>+ VOID *OldBuffer OPTIONAL
>+ );
>+
>+VOID *
>+InternalReallocatePool (
>+ UINTN OldSize,
>+ UINTN NewSize,
>+ VOID *OldBuffer OPTIONAL
>+ );
>+
>+VOID *
>+InternalAllocateZeroPool (
>+ UINTN AllocationSize
>+ ) ;
>+
>+VOID *
>+InternalAllocatePool (
>+ UINTN AllocationSize
>+ );
>+
>+UINTN
>+StrnLenS (
>+ CONST CHAR16 *String,
>+ UINTN MaxSize
>+ );
>+
>+CHAR16
>+InternalCharToUpper (
>+ CHAR16 Char
>+ );
>+
>+UINTN
>+DevicePathNodeLength (
>+ CONST VOID *Node
>+ );
>+
>+UINT16
>+SetDevicePathNodeLength (
>+ VOID *Node,
>+ UINTN Length
>+ );
>+
>+INTN
>+StrCmp (
>+ CONST CHAR16 *FirstString,
>+ CONST CHAR16 *SecondString
>+ );
>+
>+UINT64
>+SwapBytes64 (
>+ UINT64 Value
>+ );
>+
>+UINT64
>+InternalMathSwapBytes64 (
>+ UINT64 Operand
>+ );
>+
>+RETURN_STATUS
>+StrToIpv4Address (
>+ CONST CHAR16 *String,
>+ CHAR16 **EndPointer,
>+ EFI_IPv4_ADDRESS *Address,
>+ UINT8 *PrefixLength
>+ );
>+
>+RETURN_STATUS
>+StrToIpv6Address (
>+ CONST CHAR16 *String,
>+ CHAR16 **EndPointer,
>+ EFI_IPv6_ADDRESS *Address,
>+ UINT8 *PrefixLength
>+ );
>+
>+RETURN_STATUS
>+StrCpyS (
>+ CHAR16 *Destination,
>+ UINTN DestMax,
>+ CONST CHAR16 *Source
>+ );
>+
>+RETURN_STATUS
>+UnicodeStrToAsciiStrS (
>+ CONST CHAR16 *Source,
>+ CHAR8 *Destination,
>+ UINTN DestMax
>+ );
>+VOID *
>+AllocatePool (
>+ UINTN AllocationSize
>+ );
>+
>+VOID
>+SetDevicePathEndNode (
>+ VOID *Node
>+ );
>+
>+BOOLEAN
>+IsDevicePathValid (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath,
>+ UINTN MaxSize
>+ );
>+
>+UINT8
>+DevicePathType (
>+ CONST VOID *Node
>+ );
>+
>+UINT8
>+DevicePathSubType (
>+ CONST VOID *Node
>+ );
>+
>+UINTN
>+DevicePathNodeLength (
>+ CONST VOID *Node
>+ );
>+
>+EFI_DEVICE_PATH_PROTOCOL *
>+NextDevicePathNode (
>+ CONST VOID *Node
>+ );
>+
>+BOOLEAN
>+IsDevicePathEndType (
>+ CONST VOID *Node
>+ );
>+
>+BOOLEAN
>+IsDevicePathEnd (
>+ CONST VOID *Node
>+ );
>+BOOLEAN
>+IsDevicePathEndInstance (
>+ CONST VOID *Node
>+ );
>+
>+UINT16
>+SetDevicePathNodeLength (
>+ VOID *Node,
>+ UINTN Length
>+ );
>+
>+VOID
>+SetDevicePathEndNode (
>+ VOID *Node
>+ );
>+
>+UINTN
>+UefiDevicePathLibGetDevicePathSize (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath
>+ );
>+
>+EFI_DEVICE_PATH_PROTOCOL *
>+UefiDevicePathLibDuplicateDevicePath (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath
>+ );
>+
>+EFI_DEVICE_PATH_PROTOCOL *
>+UefiDevicePathLibAppendDevicePath (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *FirstDevicePath,
>+ CONST EFI_DEVICE_PATH_PROTOCOL *SecondDevicePath
>+ );
>+
>+EFI_DEVICE_PATH_PROTOCOL *
>+UefiDevicePathLibAppendDevicePathNode (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath,
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePathNode
>+ );
>+
>+EFI_DEVICE_PATH_PROTOCOL *
>+UefiDevicePathLibAppendDevicePathInstance (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath,
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePathInstance
>+ );
>+
>+EFI_DEVICE_PATH_PROTOCOL *
>+UefiDevicePathLibGetNextDevicePathInstance (
>+ EFI_DEVICE_PATH_PROTOCOL **DevicePath,
>+ UINTN *Size
>+ );
>+
>+EFI_DEVICE_PATH_PROTOCOL *
>+UefiDevicePathLibCreateDeviceNode (
>+ UINT8 NodeType,
>+ UINT8 NodeSubType,
>+ UINT16 NodeLength
>+ );
>+
>+BOOLEAN
>+UefiDevicePathLibIsDevicePathMultiInstance (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath
>+ );
>+
>+UINT16
>+WriteUnaligned16 (
>+ UINT16 *Buffer,
>+ UINT16 Value
>+ );
>+
>+UINT16
>+ReadUnaligned16 (
>+ CONST UINT16 *Buffer
>+ );
>+
>+VOID *
>+AllocateZeroPool (
>+ UINTN AllocationSize
>+ );
>+
>+BOOLEAN
>+InternalIsHexaDecimalDigitCharacter (
>+ CHAR16 Char
>+ );
>+
>+BOOLEAN
>+InternalSafeStringIsOverlap (
>+ IN VOID *Base1,
>+ IN UINTN Size1,
>+ IN VOID *Base2,
>+ IN UINTN Size2
>+ );
>+
>+BOOLEAN
>+InternalSafeStringNoStrOverlap (
>+ IN CHAR16 *Str1,
>+ IN UINTN Size1,
>+ IN CHAR16 *Str2,
>+ IN UINTN Size2
>+ );
>+
>+#endif
>diff --git a/BaseTools/Source/C/DevicePath/GNUmakefile
>b/BaseTools/Source/C/DevicePath/GNUmakefile
>new file mode 100644
>index 0000000..27f6fa1
>--- /dev/null
>+++ b/BaseTools/Source/C/DevicePath/GNUmakefile
>@@ -0,0 +1,30 @@
>+## @file
>+# GNU/Linux makefile for 'DevicePath' module build.
>+#
>+# Copyright (c) 2017, Intel Corporation. All rights reserved.<BR>
>+# This program and the accompanying materials
>+# are licensed and made available under the terms and conditions of the BSD
>License
>+# which accompanies this distribution. The full text of the license may be
>found at
>+# http://opensource.org/licenses/bsd-license.php
>+#
>+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+#
>+ARCH ?= IA32
>+MAKEROOT ?= ..
>+
>+APPNAME = DevicePath
>+
>+OBJECTS = DevicePath.o UefiDevicePathLib.o DevicePathFromText.o
>DevicePathUtilities.o
>+
>+include $(MAKEROOT)/Makefiles/app.makefile
>+
>+LIBS = -lCommon
>+ifeq ($(CYGWIN), CYGWIN)
>+ LIBS += -L/lib/e2fsprogs -luuid
>+endif
>+
>+ifeq ($(LINUX), Linux)
>+ LIBS += -luuid
>+endif
>+
>diff --git a/BaseTools/Source/C/DevicePath/Makefile
>b/BaseTools/Source/C/DevicePath/Makefile
>new file mode 100644
>index 0000000..a069c22
>--- /dev/null
>+++ b/BaseTools/Source/C/DevicePath/Makefile
>@@ -0,0 +1,24 @@
>+## @file
>+# Windows makefile for 'DevicePath' module build.
>+#
>+# Copyright (c) 2017, Intel Corporation. All rights reserved.<BR>
>+# This program and the accompanying materials
>+# are licensed and made available under the terms and conditions of the BSD
>License
>+# which accompanies this distribution. The full text of the license may be
>found at
>+# http://opensource.org/licenses/bsd-license.php
>+#
>+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+#
>+!INCLUDE ..\Makefiles\ms.common
>+
>+APPNAME = DevicePath
>+
>+LIBS = $(LIB_PATH)\Common.lib
>+
>+OBJECTS = DevicePath.obj UefiDevicePathLib.obj DevicePathFromText.obj
>DevicePathUtilities.obj
>+
>+#CFLAGS = $(CFLAGS) /nodefaultlib:libc.lib
>+
>+!INCLUDE ..\Makefiles\ms.app
>+
>diff --git a/BaseTools/Source/C/DevicePath/UefiDevicePathLib.c
>b/BaseTools/Source/C/DevicePath/UefiDevicePathLib.c
>new file mode 100644
>index 0000000..a2e0322
>--- /dev/null
>+++ b/BaseTools/Source/C/DevicePath/UefiDevicePathLib.c
>@@ -0,0 +1,298 @@
>+/** @file
>+ Device Path services. The thing to remember is device paths are built out of
>+ nodes. The device path is terminated by an end node that is length
>+ sizeof(EFI_DEVICE_PATH_PROTOCOL). That would be why there is
>sizeof(EFI_DEVICE_PATH_PROTOCOL)
>+ all over this file.
>+
>+ The only place where multi-instance device paths are supported is in
>+ environment varibles. Multi-instance device paths should never be placed
>+ on a Handle.
>+
>+ Copyright (c) 2017, Intel Corporation. All rights reserved.<BR>
>+ This program and the accompanying materials
>+ are licensed and made available under the terms and conditions of the BSD
>License
>+ which accompanies this distribution. The full text of the license may be
>found at
>+ http://opensource.org/licenses/bsd-license.php.
>+
>+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+**/
>+
>+
>+#include "UefiDevicePathLib.h"
>+
>+/**
>+ Returns the size of a device path in bytes.
>+
>+ This function returns the size, in bytes, of the device path data structure
>+ specified by DevicePath including the end of device path node.
>+ If DevicePath is NULL or invalid, then 0 is returned.
>+
>+ @param DevicePath A pointer to a device path data structure.
>+
>+ @retval 0 If DevicePath is NULL or invalid.
>+ @retval Others The size of a device path in bytes.
>+
>+**/
>+UINTN
>+GetDevicePathSize (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath
>+ )
>+{
>+ return UefiDevicePathLibGetDevicePathSize (DevicePath);
>+}
>+
>+/**
>+ Creates a new copy of an existing device path.
>+
>+ This function allocates space for a new copy of the device path specified by
>DevicePath.
>+ If DevicePath is NULL, then NULL is returned. If the memory is successfully
>+ allocated, then the contents of DevicePath are copied to the newly
>allocated
>+ buffer, and a pointer to that buffer is returned. Otherwise, NULL is
>returned.
>+ The memory for the new device path is allocated from EFI boot services
>memory.
>+ It is the responsibility of the caller to free the memory allocated.
>+
>+ @param DevicePath A pointer to a device path data structure.
>+
>+ @retval NULL DevicePath is NULL or invalid.
>+ @retval Others A pointer to the duplicated device path.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+DuplicateDevicePath (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath
>+ )
>+{
>+ return UefiDevicePathLibDuplicateDevicePath (DevicePath);
>+}
>+
>+/**
>+ Creates a new device path by appending a second device path to a first
>device path.
>+
>+ This function creates a new device path by appending a copy of
>SecondDevicePath
>+ to a copy of FirstDevicePath in a newly allocated buffer. Only the end-of-
>device-path
>+ device node from SecondDevicePath is retained. The newly created device
>path is
>+ returned. If FirstDevicePath is NULL, then it is ignored, and a duplicate of
>+ SecondDevicePath is returned. If SecondDevicePath is NULL, then it is
>ignored,
>+ and a duplicate of FirstDevicePath is returned. If both FirstDevicePath and
>+ SecondDevicePath are NULL, then a copy of an end-of-device-path is
>returned.
>+
>+ If there is not enough memory for the newly allocated buffer, then NULL is
>returned.
>+ The memory for the new device path is allocated from EFI boot services
>memory.
>+ It is the responsibility of the caller to free the memory allocated.
>+
>+ @param FirstDevicePath A pointer to a device path data structure.
>+ @param SecondDevicePath A pointer to a device path data structure.
>+
>+ @retval NULL If there is not enough memory for the newly allocated
>buffer.
>+ @retval NULL If FirstDevicePath or SecondDevicePath is invalid.
>+ @retval Others A pointer to the new device path if success.
>+ Or a copy an end-of-device-path if both FirstDevicePath and
>SecondDevicePath are NULL.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+AppendDevicePath (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *FirstDevicePath, OPTIONAL
>+ CONST EFI_DEVICE_PATH_PROTOCOL *SecondDevicePath OPTIONAL
>+ )
>+{
>+ return UefiDevicePathLibAppendDevicePath (FirstDevicePath,
>SecondDevicePath);
>+}
>+
>+/**
>+ Creates a new path by appending the device node to the device path.
>+
>+ This function creates a new device path by appending a copy of the device
>node
>+ specified by DevicePathNode to a copy of the device path specified by
>DevicePath
>+ in an allocated buffer. The end-of-device-path device node is moved after
>the
>+ end of the appended device node.
>+ If DevicePathNode is NULL then a copy of DevicePath is returned.
>+ If DevicePath is NULL then a copy of DevicePathNode, followed by an end-
>of-device
>+ path device node is returned.
>+ If both DevicePathNode and DevicePath are NULL then a copy of an end-of-
>device-path
>+ device node is returned.
>+ If there is not enough memory to allocate space for the new device path,
>then
>+ NULL is returned.
>+ The memory is allocated from EFI boot services memory. It is the
>responsibility
>+ of the caller to free the memory allocated.
>+
>+ @param DevicePath A pointer to a device path data structure.
>+ @param DevicePathNode A pointer to a single device path node.
>+
>+ @retval NULL If there is not enough memory for the new device path.
>+ @retval Others A pointer to the new device path if success.
>+ A copy of DevicePathNode followed by an end-of-device-path
>node
>+ if both FirstDevicePath and SecondDevicePath are NULL.
>+ A copy of an end-of-device-path node if both FirstDevicePath
>+ and SecondDevicePath are NULL.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+AppendDevicePathNode (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath, OPTIONAL
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePathNode OPTIONAL
>+ )
>+{
>+ return UefiDevicePathLibAppendDevicePathNode (DevicePath,
>DevicePathNode);
>+}
>+
>+/**
>+ Creates a new device path by appending the specified device path instance
>to the specified device
>+ path.
>+
>+ This function creates a new device path by appending a copy of the device
>path
>+ instance specified by DevicePathInstance to a copy of the device path
>specified
>+ by DevicePath in a allocated buffer.
>+ The end-of-device-path device node is moved after the end of the
>appended device
>+ path instance and a new end-of-device-path-instance node is inserted
>between.
>+ If DevicePath is NULL, then a copy if DevicePathInstance is returned.
>+ If DevicePathInstance is NULL, then NULL is returned.
>+ If DevicePath or DevicePathInstance is invalid, then NULL is returned.
>+ If there is not enough memory to allocate space for the new device path,
>then
>+ NULL is returned.
>+ The memory is allocated from EFI boot services memory. It is the
>responsibility
>+ of the caller to free the memory allocated.
>+
>+ @param DevicePath A pointer to a device path data structure.
>+ @param DevicePathInstance A pointer to a device path instance.
>+
>+ @return A pointer to the new device path.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+AppendDevicePathInstance (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath, OPTIONAL
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePathInstance OPTIONAL
>+ )
>+{
>+ return UefiDevicePathLibAppendDevicePathInstance (DevicePath,
>DevicePathInstance);
>+}
>+
>+/**
>+ Creates a copy of the current device path instance and returns a pointer to
>the next device path
>+ instance.
>+
>+ This function creates a copy of the current device path instance. It also
>updates
>+ DevicePath to point to the next device path instance in the device path (or
>NULL
>+ if no more) and updates Size to hold the size of the device path instance
>copy.
>+ If DevicePath is NULL, then NULL is returned.
>+ If DevicePath points to a invalid device path, then NULL is returned.
>+ If there is not enough memory to allocate space for the new device path,
>then
>+ NULL is returned.
>+ The memory is allocated from EFI boot services memory. It is the
>responsibility
>+ of the caller to free the memory allocated.
>+ If Size is NULL, then ASSERT().
>+
>+ @param DevicePath On input, this holds the pointer to the current
>+ device path instance. On output, this holds
>+ the pointer to the next device path instance
>+ or NULL if there are no more device path
>+ instances in the device path pointer to a
>+ device path data structure.
>+ @param Size On output, this holds the size of the device
>+ path instance, in bytes or zero, if DevicePath
>+ is NULL.
>+
>+ @return A pointer to the current device path instance.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+GetNextDevicePathInstance (
>+ EFI_DEVICE_PATH_PROTOCOL **DevicePath,
>+ UINTN *Size
>+ )
>+{
>+ return UefiDevicePathLibGetNextDevicePathInstance (DevicePath, Size);
>+}
>+
>+/**
>+ Creates a device node.
>+
>+ This function creates a new device node in a newly allocated buffer of size
>+ NodeLength and initializes the device path node header with NodeType
>and NodeSubType.
>+ The new device path node is returned.
>+ If NodeLength is smaller than a device path header, then NULL is returned.
>+ If there is not enough memory to allocate space for the new device path,
>then
>+ NULL is returned.
>+ The memory is allocated from EFI boot services memory. It is the
>responsibility
>+ of the caller to free the memory allocated.
>+
>+ @param NodeType The device node type for the new device
>node.
>+ @param NodeSubType The device node sub-type for the new
>device node.
>+ @param NodeLength The length of the new device node.
>+
>+ @return The new device path.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+CreateDeviceNode (
>+ UINT8 NodeType,
>+ UINT8 NodeSubType,
>+ UINT16 NodeLength
>+ )
>+{
>+ return UefiDevicePathLibCreateDeviceNode (NodeType, NodeSubType,
>NodeLength);
>+}
>+
>+/**
>+ Determines if a device path is single or multi-instance.
>+
>+ This function returns TRUE if the device path specified by DevicePath is
>+ multi-instance.
>+ Otherwise, FALSE is returned.
>+ If DevicePath is NULL or invalid, then FALSE is returned.
>+
>+ @param DevicePath A pointer to a device path data structure.
>+
>+ @retval TRUE DevicePath is multi-instance.
>+ @retval FALSE DevicePath is not multi-instance, or DevicePath
>+ is NULL or invalid.
>+
>+**/
>+BOOLEAN
>+IsDevicePathMultiInstance (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath
>+ )
>+{
>+ return UefiDevicePathLibIsDevicePathMultiInstance (DevicePath);
>+}
>+
>+/**
>+ Convert text to the binary representation of a device node.
>+
>+ @param TextDeviceNode TextDeviceNode points to the text
>representation of a device
>+ node. Conversion starts with the first character and continues
>+ until the first non-device node character.
>+
>+ @return A pointer to the EFI device node or NULL if TextDeviceNode is
>NULL or there was
>+ insufficient memory or text unsupported.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+ConvertTextToDeviceNode (
>+ CONST CHAR16 *TextDeviceNode
>+ )
>+{
>+ return UefiDevicePathLibConvertTextToDeviceNode (TextDeviceNode);
>+}
>+
>+/**
>+ Convert text to the binary representation of a device path.
>+
>+
>+ @param TextDevicePath TextDevicePath points to the text representation
>of a device
>+ path. Conversion starts with the first character and continues
>+ until the first non-device node character.
>+
>+ @return A pointer to the allocated device path or NULL if TextDeviceNode
>is NULL or
>+ there was insufficient memory.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+ConvertTextToDevicePath (
>+ CONST CHAR16 *TextDevicePath
>+ )
>+{
>+ return UefiDevicePathLibConvertTextToDevicePath (TextDevicePath);
>+}
>diff --git a/BaseTools/Source/C/DevicePath/UefiDevicePathLib.h
>b/BaseTools/Source/C/DevicePath/UefiDevicePathLib.h
>new file mode 100644
>index 0000000..e03fbd0
>--- /dev/null
>+++ b/BaseTools/Source/C/DevicePath/UefiDevicePathLib.h
>@@ -0,0 +1,473 @@
>+/** @file
>+ Definition for Device Path library.
>+
>+Copyright (c) 2017, Intel Corporation. All rights reserved.<BR>
>+This program and the accompanying materials
>+are licensed and made available under the terms and conditions of the BSD
>License
>+which accompanies this distribution. The full text of the license may be
>found at
>+http://opensource.org/licenses/bsd-license.php
>+
>+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"
>BASIS,
>+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER
>EXPRESS OR IMPLIED.
>+
>+**/
>+#ifndef _UEFI_DEVICE_PATH_LIB_H_
>+#define _UEFI_DEVICE_PATH_LIB_H_
>+
>+#include <stdio.h>
>+#include <stdlib.h>
>+#include <string.h>
>+#include <ctype.h>
>+#include <assert.h>
>+#ifdef __GNUC__
>+#include <unistd.h>
>+#else
>+#include <direct.h>
>+#endif
>+#include <Common/UefiBaseTypes.h>
>+#include "CommonLib.h"
>+#include "EfiUtilityMsgs.h"
>+#include "DevicePath.h"
>+#include "DevicePathUtilities.h"
>+#include "DevicePathFromText.h"
>+
>+
>+#define IS_COMMA(a) ((a) == L',')
>+#define IS_HYPHEN(a) ((a) == L'-')
>+#define IS_DOT(a) ((a) == L'.')
>+#define IS_LEFT_PARENTH(a) ((a) == L'(')
>+#define IS_RIGHT_PARENTH(a) ((a) == L')')
>+#define IS_SLASH(a) ((a) == L'/')
>+#define IS_NULL(a) ((a) == L'\0')
>+
>+#define MAX_UINTN MAX_ADDRESS
>+#define MAX_UINT64 ((UINT64)0xFFFFFFFFFFFFFFFFULL)
>+#define MAX_UINT16 ((UINT16)0xFFFF)
>+#define MAX_UINT8 ((UINT8)0xFF)
>+
>+#define END_DEVICE_PATH_LENGTH (sizeof
>(EFI_DEVICE_PATH_PROTOCOL))
>+#define MAX_DEVICE_PATH_NODE_COUNT 1024
>+#define SIZE_64KB 0x00010000
>+#define ARRAY_SIZE(Array) (sizeof (Array) / sizeof ((Array)[0]))
>+#define ASCII_RSIZE_MAX 1000000
>+#ifndef RSIZE_MAX
>+#define RSIZE_MAX 1000000
>+#endif
>+
>+//
>+// Private Data structure
>+//
>+typedef
>+EFI_DEVICE_PATH_PROTOCOL *
>+(*DEVICE_PATH_FROM_TEXT) (
>+ IN CHAR16 *Str
>+ );
>+
>+typedef struct {
>+ CHAR16 *Str;
>+ UINTN Count;
>+ UINTN Capacity;
>+} POOL_PRINT;
>+
>+
>+typedef struct {
>+ CHAR16 *DevicePathNodeText;
>+ DEVICE_PATH_FROM_TEXT Function;
>+} DEVICE_PATH_FROM_TEXT_TABLE;
>+
>+typedef struct {
>+ BOOLEAN ClassExist;
>+ UINT8 Class;
>+ BOOLEAN SubClassExist;
>+ UINT8 SubClass;
>+} USB_CLASS_TEXT;
>+
>+#define USB_CLASS_AUDIO 1
>+#define USB_CLASS_CDCCONTROL 2
>+#define USB_CLASS_HID 3
>+#define USB_CLASS_IMAGE 6
>+#define USB_CLASS_PRINTER 7
>+#define USB_CLASS_MASS_STORAGE 8
>+#define USB_CLASS_HUB 9
>+#define USB_CLASS_CDCDATA 10
>+#define USB_CLASS_SMART_CARD 11
>+#define USB_CLASS_VIDEO 14
>+#define USB_CLASS_DIAGNOSTIC 220
>+#define USB_CLASS_WIRELESS 224
>+
>+#define USB_CLASS_RESERVE 254
>+#define USB_SUBCLASS_FW_UPDATE 1
>+#define USB_SUBCLASS_IRDA_BRIDGE 2
>+#define USB_SUBCLASS_TEST 3
>+
>+#define RFC_1700_UDP_PROTOCOL 17
>+#define RFC_1700_TCP_PROTOCOL 6
>+
>+#pragma pack(1)
>+
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ EFI_GUID Guid;
>+ UINT8 VendorDefinedData[1];
>+} VENDOR_DEFINED_HARDWARE_DEVICE_PATH;
>+
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ EFI_GUID Guid;
>+ UINT8 VendorDefinedData[1];
>+} VENDOR_DEFINED_MESSAGING_DEVICE_PATH;
>+
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ EFI_GUID Guid;
>+ UINT8 VendorDefinedData[1];
>+} VENDOR_DEFINED_MEDIA_DEVICE_PATH;
>+
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ UINT32 Hid;
>+ UINT32 Uid;
>+ UINT32 Cid;
>+ CHAR8 HidUidCidStr[3];
>+} ACPI_EXTENDED_HID_DEVICE_PATH_WITH_STR;
>+
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ UINT16 NetworkProtocol;
>+ UINT16 LoginOption;
>+ UINT64 Lun;
>+ UINT16 TargetPortalGroupTag;
>+ CHAR8 TargetName[1];
>+} ISCSI_DEVICE_PATH_WITH_NAME;
>+
>+typedef struct {
>+ EFI_DEVICE_PATH_PROTOCOL Header;
>+ EFI_GUID Guid;
>+ UINT8 VendorDefinedData[1];
>+} VENDOR_DEVICE_PATH_WITH_DATA;
>+
>+#pragma pack()
>+
>+/**
>+ Returns the size of a device path in bytes.
>+
>+ This function returns the size, in bytes, of the device path data structure
>+ specified by DevicePath including the end of device path node.
>+ If DevicePath is NULL or invalid, then 0 is returned.
>+
>+ @param DevicePath A pointer to a device path data structure.
>+
>+ @retval 0 If DevicePath is NULL or invalid.
>+ @retval Others The size of a device path in bytes.
>+
>+**/
>+UINTN
>+UefiDevicePathLibGetDevicePathSize (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath
>+ );
>+
>+/**
>+ Creates a new copy of an existing device path.
>+
>+ This function allocates space for a new copy of the device path specified by
>DevicePath.
>+ If DevicePath is NULL, then NULL is returned. If the memory is successfully
>+ allocated, then the contents of DevicePath are copied to the newly
>allocated
>+ buffer, and a pointer to that buffer is returned. Otherwise, NULL is
>returned.
>+ The memory for the new device path is allocated from EFI boot services
>memory.
>+ It is the responsibility of the caller to free the memory allocated.
>+
>+ @param DevicePath A pointer to a device path data structure.
>+
>+ @retval NULL DevicePath is NULL or invalid.
>+ @retval Others A pointer to the duplicated device path.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+UefiDevicePathLibDuplicateDevicePath (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath
>+ );
>+
>+/**
>+ Creates a new device path by appending a second device path to a first
>device path.
>+
>+ This function creates a new device path by appending a copy of
>SecondDevicePath
>+ to a copy of FirstDevicePath in a newly allocated buffer. Only the end-of-
>device-path
>+ device node from SecondDevicePath is retained. The newly created device
>path is
>+ returned. If FirstDevicePath is NULL, then it is ignored, and a duplicate of
>+ SecondDevicePath is returned. If SecondDevicePath is NULL, then it is
>ignored,
>+ and a duplicate of FirstDevicePath is returned. If both FirstDevicePath and
>+ SecondDevicePath are NULL, then a copy of an end-of-device-path is
>returned.
>+
>+ If there is not enough memory for the newly allocated buffer, then NULL is
>returned.
>+ The memory for the new device path is allocated from EFI boot services
>memory.
>+ It is the responsibility of the caller to free the memory allocated.
>+
>+ @param FirstDevicePath A pointer to a device path data structure.
>+ @param SecondDevicePath A pointer to a device path data structure.
>+
>+ @retval NULL If there is not enough memory for the newly allocated
>buffer.
>+ @retval NULL If FirstDevicePath or SecondDevicePath is invalid.
>+ @retval Others A pointer to the new device path if success.
>+ Or a copy an end-of-device-path if both FirstDevicePath and
>SecondDevicePath are NULL.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+UefiDevicePathLibAppendDevicePath (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *FirstDevicePath, OPTIONAL
>+ CONST EFI_DEVICE_PATH_PROTOCOL *SecondDevicePath OPTIONAL
>+ );
>+
>+/**
>+ Creates a new path by appending the device node to the device path.
>+
>+ This function creates a new device path by appending a copy of the device
>node
>+ specified by DevicePathNode to a copy of the device path specified by
>DevicePath
>+ in an allocated buffer. The end-of-device-path device node is moved after
>the
>+ end of the appended device node.
>+ If DevicePathNode is NULL then a copy of DevicePath is returned.
>+ If DevicePath is NULL then a copy of DevicePathNode, followed by an end-
>of-device
>+ path device node is returned.
>+ If both DevicePathNode and DevicePath are NULL then a copy of an end-of-
>device-path
>+ device node is returned.
>+ If there is not enough memory to allocate space for the new device path,
>then
>+ NULL is returned.
>+ The memory is allocated from EFI boot services memory. It is the
>responsibility
>+ of the caller to free the memory allocated.
>+
>+ @param DevicePath A pointer to a device path data structure.
>+ @param DevicePathNode A pointer to a single device path node.
>+
>+ @retval NULL If there is not enough memory for the new device path.
>+ @retval Others A pointer to the new device path if success.
>+ A copy of DevicePathNode followed by an end-of-device-path
>node
>+ if both FirstDevicePath and SecondDevicePath are NULL.
>+ A copy of an end-of-device-path node if both FirstDevicePath
>+ and SecondDevicePath are NULL.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+UefiDevicePathLibAppendDevicePathNode (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath, OPTIONAL
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePathNode OPTIONAL
>+ );
>+
>+/**
>+ Creates a new device path by appending the specified device path instance
>to the specified device
>+ path.
>+
>+ This function creates a new device path by appending a copy of the device
>path
>+ instance specified by DevicePathInstance to a copy of the device path
>specified
>+ by DevicePath in a allocated buffer.
>+ The end-of-device-path device node is moved after the end of the
>appended device
>+ path instance and a new end-of-device-path-instance node is inserted
>between.
>+ If DevicePath is NULL, then a copy if DevicePathInstance is returned.
>+ If DevicePathInstance is NULL, then NULL is returned.
>+ If DevicePath or DevicePathInstance is invalid, then NULL is returned.
>+ If there is not enough memory to allocate space for the new device path,
>then
>+ NULL is returned.
>+ The memory is allocated from EFI boot services memory. It is the
>responsibility
>+ of the caller to free the memory allocated.
>+
>+ @param DevicePath A pointer to a device path data structure.
>+ @param DevicePathInstance A pointer to a device path instance.
>+
>+ @return A pointer to the new device path.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+UefiDevicePathLibAppendDevicePathInstance (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath, OPTIONAL
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePathInstance OPTIONAL
>+ );
>+
>+/**
>+ Creates a copy of the current device path instance and returns a pointer to
>the next device path
>+ instance.
>+
>+ This function creates a copy of the current device path instance. It also
>updates
>+ DevicePath to point to the next device path instance in the device path (or
>NULL
>+ if no more) and updates Size to hold the size of the device path instance
>copy.
>+ If DevicePath is NULL, then NULL is returned.
>+ If DevicePath points to a invalid device path, then NULL is returned.
>+ If there is not enough memory to allocate space for the new device path,
>then
>+ NULL is returned.
>+ The memory is allocated from EFI boot services memory. It is the
>responsibility
>+ of the caller to free the memory allocated.
>+ If Size is NULL, then ASSERT().
>+
>+ @param DevicePath On input, this holds the pointer to the current
>+ device path instance. On output, this holds
>+ the pointer to the next device path instance
>+ or NULL if there are no more device path
>+ instances in the device path pointer to a
>+ device path data structure.
>+ @param Size On output, this holds the size of the device
>+ path instance, in bytes or zero, if DevicePath
>+ is NULL.
>+
>+ @return A pointer to the current device path instance.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+UefiDevicePathLibGetNextDevicePathInstance (
>+ EFI_DEVICE_PATH_PROTOCOL **DevicePath,
>+ UINTN *Size
>+ );
>+
>+/**
>+ Creates a device node.
>+
>+ This function creates a new device node in a newly allocated buffer of size
>+ NodeLength and initializes the device path node header with NodeType
>and NodeSubType.
>+ The new device path node is returned.
>+ If NodeLength is smaller than a device path header, then NULL is returned.
>+ If there is not enough memory to allocate space for the new device path,
>then
>+ NULL is returned.
>+ The memory is allocated from EFI boot services memory. It is the
>responsibility
>+ of the caller to free the memory allocated.
>+
>+ @param NodeType The device node type for the new device
>node.
>+ @param NodeSubType The device node sub-type for the new
>device node.
>+ @param NodeLength The length of the new device node.
>+
>+ @return The new device path.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+UefiDevicePathLibCreateDeviceNode (
>+ UINT8 NodeType,
>+ UINT8 NodeSubType,
>+ UINT16 NodeLength
>+ );
>+
>+/**
>+ Determines if a device path is single or multi-instance.
>+
>+ This function returns TRUE if the device path specified by DevicePath is
>+ multi-instance.
>+ Otherwise, FALSE is returned.
>+ If DevicePath is NULL or invalid, then FALSE is returned.
>+
>+ @param DevicePath A pointer to a device path data structure.
>+
>+ @retval TRUE DevicePath is multi-instance.
>+ @retval FALSE DevicePath is not multi-instance, or DevicePath
>+ is NULL or invalid.
>+
>+**/
>+BOOLEAN
>+UefiDevicePathLibIsDevicePathMultiInstance (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath
>+ );
>+
>+/**
>+ Convert text to the binary representation of a device node.
>+
>+ @param TextDeviceNode TextDeviceNode points to the text
>representation of a device
>+ node. Conversion starts with the first character and continues
>+ until the first non-device node character.
>+
>+ @return A pointer to the EFI device node or NULL if TextDeviceNode is
>NULL or there was
>+ insufficient memory or text unsupported.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+UefiDevicePathLibConvertTextToDeviceNode (
>+ CONST CHAR16 *TextDeviceNode
>+ );
>+
>+/**
>+ Convert text to the binary representation of a device path.
>+
>+
>+ @param TextDevicePath TextDevicePath points to the text representation
>of a device
>+ path. Conversion starts with the first character and continues
>+ until the first non-device node character.
>+
>+ @return A pointer to the allocated device path or NULL if TextDeviceNode
>is NULL or
>+ there was insufficient memory.
>+
>+**/
>+EFI_DEVICE_PATH_PROTOCOL *
>+UefiDevicePathLibConvertTextToDevicePath (
>+ CONST CHAR16 *TextDevicePath
>+ );
>+
>+EFI_DEVICE_PATH_PROTOCOL *
>+CreateDeviceNode (
>+ UINT8 NodeType,
>+ UINT8 NodeSubType,
>+ UINT16 NodeLength
>+ );
>+
>+ EFI_DEVICE_PATH_PROTOCOL *
>+CreateDeviceNode (
>+ UINT8 NodeType,
>+ UINT8 NodeSubType,
>+ UINT16 NodeLength
>+ );
>+
>+BOOLEAN
>+IsDevicePathMultiInstance (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath
>+ );
>+
>+EFI_DEVICE_PATH_PROTOCOL *
>+GetNextDevicePathInstance (
>+ EFI_DEVICE_PATH_PROTOCOL **DevicePath,
>+ UINTN *Size
>+ );
>+
>+EFI_DEVICE_PATH_PROTOCOL *
>+AppendDevicePathInstance (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath, OPTIONAL
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePathInstance OPTIONAL
>+ );
>+
>+EFI_DEVICE_PATH_PROTOCOL *
>+AppendDevicePathNode (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath, OPTIONAL
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePathNode OPTIONAL
>+ );
>+EFI_DEVICE_PATH_PROTOCOL *
>+AppendDevicePath (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *FirstDevicePath, OPTIONAL
>+ CONST EFI_DEVICE_PATH_PROTOCOL *SecondDevicePath OPTIONAL
>+ );
>+
>+EFI_DEVICE_PATH_PROTOCOL *
>+DuplicateDevicePath (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath
>+ );
>+
>+UINTN
>+GetDevicePathSize (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath
>+ );
>+
>+CHAR16 *
>+ConvertDeviceNodeToText (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DeviceNode,
>+ BOOLEAN DisplayOnly,
>+ BOOLEAN AllowShortcuts
>+ );
>+
>+CHAR16 *
>+ConvertDevicePathToText (
>+ CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath,
>+ BOOLEAN DisplayOnly,
>+ BOOLEAN AllowShortcuts
>+ );
>+
>+EFI_DEVICE_PATH_PROTOCOL *
>+ConvertTextToDeviceNode (
>+ CONST CHAR16 *TextDeviceNode
>+ );
>+
>+EFI_DEVICE_PATH_PROTOCOL *
>+ConvertTextToDevicePath (
>+ CONST CHAR16 *TextDevicePath
>+ );
>+
>+
>+#endif
>diff --git a/BaseTools/Source/C/GNUmakefile
>b/BaseTools/Source/C/GNUmakefile
>index 0dc7482..37421ad 100644
>--- a/BaseTools/Source/C/GNUmakefile
>+++ b/BaseTools/Source/C/GNUmakefile
>@@ -65,11 +65,12 @@ APPLICATIONS = \
> GenCrc32 \
> GenVtf \
> LzmaCompress \
> Split \
> TianoCompress \
>- VolInfo
>+ VolInfo \
>+ DevicePath
>
> SUBDIRS := $(LIBRARIES) $(APPLICATIONS)
>
> $(LIBRARIES): $(MAKEROOT)/libs
> $(APPLICATIONS): $(LIBRARIES) $(MAKEROOT)/bin $(VFRAUTOGEN)
>diff --git a/BaseTools/Source/C/Makefile b/BaseTools/Source/C/Makefile
>index 50be773..5428180 100644
>--- a/BaseTools/Source/C/Makefile
>+++ b/BaseTools/Source/C/Makefile
>@@ -1,9 +1,9 @@
> ## @file
> # Windows makefile for C tools build.
> #
>-# Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
>+# Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
> # This program and the accompanying materials
> # are licensed and made available under the terms and conditions of the BSD
>License
> # which accompanies this distribution. The full text of the license may be
>found at
> # http://opensource.org/licenses/bsd-license.php
> #
>@@ -30,11 +30,12 @@ APPLICATIONS = \
> GenVtf \
> LzmaCompress \
> Split \
> TianoCompress \
> VolInfo \
>- VfrCompile
>+ VfrCompile \
>+ DevicePath
>
> all: libs apps install
>
> libs: $(LIBRARIES)
> @echo.
>diff --git a/BaseTools/Source/Python/Common/Misc.py
>b/BaseTools/Source/Python/Common/Misc.py
>index c51b685..104a370 100644
>--- a/BaseTools/Source/Python/Common/Misc.py
>+++ b/BaseTools/Source/Python/Common/Misc.py
>@@ -36,11 +36,11 @@ from CommonDataClass.DataClass import *
> from Parsing import GetSplitValueList
> from Common.LongFilePathSupport import OpenLongFilePath as open
> from Common.MultipleWorkspace import MultipleWorkspace as mws
> import uuid
> from CommonDataClass.Exceptions import BadExpression
>-
>+import subprocess
> ## Regular expression used to find out place holders in string template
> gPlaceholderPattern = re.compile("\$\{([^$()\s]+)\}", re.MULTILINE |
>re.UNICODE)
>
> ## Dictionary used to store file time stamp for quick re-access
> gFileTimeStampCache = {} # {file path : file time stamp}
>@@ -1472,11 +1472,42 @@ def AnalyzePcdExpression(Setting):
> StartPos = Pos + 1
>
> return FieldList
>
> def ParseDevPathValue (Value):
>- pass
>+ DevPathList =
>[ "Path","HardwarePath","Pci","PcCard","MemoryMapped","VenHw","Ctrl","
>BMC","AcpiPath","Acpi","PciRoot",
>+
>"PcieRoot","Floppy","Keyboard","Serial","ParallelPort","AcpiEx","AcpiExp","A
>cpiAdr","Msg","Ata","Scsi",
>+
>"Fibre","FibreEx","I1394","USB","I2O","Infiniband","VenMsg","VenPcAnsi","V
>enVt100","VenVt100Plus",
>+
>"VenUtf8","UartFlowCtrl","SAS","SasEx","NVMe","UFS","SD","eMMC","Debu
>gPort","MAC","IPv4","IPv6","Uart",
>+
>"UsbClass","UsbAudio","UsbCDCControl","UsbHID","UsbImage","UsbPrinter"
>,"UsbMassStorage","UsbHub",
>+
>"UsbCDCData","UsbSmartCard","UsbVideo","UsbDiagnostic","UsbWireless","
>UsbDeviceFirmwareUpdate",
>+
>"UsbIrdaBridge","UsbTestAndMeasurement","UsbWwid","Unit","iSCSI","Vla
>n","Uri","Bluetooth","Wi-Fi",
>+
>"MediaPath","HD","CDROM","VenMedia","Media","Fv","FvFile","Offset","Ra
>mDisk","VirtualDisk","VirtualCD",
>+
>"PersistentVirtualDisk","PersistentVirtualCD","BbsPath","BBS","Sata" ]
>+ if '\\' in Value:
>+ Value.replace('\\', '/').replace(' ', '')
>+ for Item in Value.split('/'):
>+ Key = Item.strip().split('(')[0]
>+ if Key not in DevPathList:
>+ pass
>+
>+ Cmd = 'DevicePath ' + '"' + Value + '"'
>+ try:
>+ p = subprocess.Popen(Cmd, stdout=subprocess.PIPE,
>stderr=subprocess.PIPE, shell=True)
>+ out, err = p.communicate()
>+ except Exception, X:
>+ raise BadExpression("DevicePath: %s" % (str(X)) )
>+ finally:
>+ subprocess._cleanup()
>+ p.stdout.close()
>+ p.stderr.close()
>+ if err:
>+ raise BadExpression("DevicePath: %s" % str(err))
>+ Size = len(out.split())
>+ out = ','.join(out.split())
>+ return '{' + out + '}', Size
>+
>
> def ParseFieldValue (Value):
> if type(Value) == type(0):
> return Value, (Value.bit_length() + 7) / 8
> if type(Value) <> type(''):
>diff --git a/BaseTools/Source/Python/Workspace/DscBuildData.py
>b/BaseTools/Source/Python/Workspace/DscBuildData.py
>index 05b26a3..f9cd429 100644
>--- a/BaseTools/Source/Python/Workspace/DscBuildData.py
>+++ b/BaseTools/Source/Python/Workspace/DscBuildData.py
>@@ -2060,11 +2060,11 @@ class DscBuildData(PlatformBuildClassObject):
> ModuleFile = PathClass(NormPath(Inf), GlobalData.gWorkspace,
>Arch=self._Arch)
> if ModuleFile in self._Modules:
> continue
> ModuleData = self._Bdb[ModuleFile, self._Arch, self._Target,
>self._Toolchain]
> PkgSet.update(ModuleData.Packages)
>- self._DecPcds = GetDeclaredPcd(self, self._Bdb, self._Arch,
>self._Target, self._Toolchain,PkgSet)
>+ self._DecPcds, self._GuidDict = GetDeclaredPcd(self, self._Bdb,
>self._Arch, self._Target, self._Toolchain,PkgSet)
> return self._DecPcds
> _Macros = property(_GetMacros)
> Arch = property(_GetArch, _SetArch)
> Platform = property(_GetPlatformName)
> PlatformName = property(_GetPlatformName)
>--
>2.6.1.windows.1
>
>_______________________________________________
>edk2-devel mailing list
>edk2-devel@lists.01.org
>https://lists.01.org/mailman/listinfo/edk2-devel
prev parent reply other threads:[~2017-12-27 2:35 UTC|newest]
Thread overview: 4+ messages / expand[flat|nested] mbox.gz Atom feed top
2017-12-26 16:40 [Patch 0/2] BaseTools: Add Flexible PCD Value support Yonghong Zhu
2017-12-26 16:40 ` [Patch 1/2] BaseTools: Support PCD flexible values format Yonghong Zhu
2017-12-26 16:40 ` [Patch 2/2] BaseTools: Add DevicePath support for PCD values Yonghong Zhu
2017-12-27 2:40 ` Gao, Liming [this message]
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-list from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=4A89E2EF3DFEDB4C8BFDE51014F606A14E198EB9@SHSMSX104.ccr.corp.intel.com \
--to=devel@edk2.groups.io \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox